Go pour les développeurs JavaScript

Voir la vidéo

Dans cette vidéo je vous propose de faire découvrir le langage Go pour les développeur JavaScript. L'objectif est de faire des analogies pour vous montrer les particularité du langages et élargir vos horizons.

00:00 Présentation
02:00 Structure de base
05:14 Syntaxe de go
08:19 Les pointeurs
10:19 Tableaux et Slices
17:38 Object vs Map
19:19 Les structs
20:50 Les méthodes
22:54 Les interfaces
25:30 Contacter une API & parser du JSON
33:50 Goroutine
39:38 Créer un serveur web
46:43 Utiliser des librairies tiers
49:20 Conclusion

Qu'est ce que Go

Go est un langage qui a été créé par des ingénieurs de Google (Robert Griesemer, Rob Pike, et Ken Thompson) avec comme objectif de remplacer le langage C++ avec lequel ils rencontrés des problèmes (une complexité trop importante et des temps de compilation trop long notamment). Il offre plusieurs avantages :

  • Une syntaxe simple facile à écrire et à lire
  • Un typage statique
  • Un temps de compilation rapide (même pour de gros projets)
  • Une gestion native de la concurrence
  • Une librairie standart conséquente pour répondre à la plupart des problématiques

Analogies avec JavaScript

Plutôt que de vous faire une présentation complète du langage, que vous pourrez de toute façon retrouver sur le Tour of go je me suis dit qu'il serait intéréssant de vous parler des points clefs qui différencie ce langage des autres.

Pas d'export

En JavaScript on exporte les éléments de manière explicite au sein d'un fichier

export const mafonction = () => {}

Dans le cadre de Go les choses sont plus original car tous les éléments commençant par une majuscule seront automatiquement exporté. La casse a donc une importance toute particulière.

Un formatteur inclue

Go intègre par défaut un outil de formattage du code qui permet d'éviter les discussions autour d'un choix de conventions.

go fmt .

Array & Slice

En Go il existe un type supplémentaire pour gérer les tableau pour une meilleur gestion mémoire.

a := [3]{1, 2, 3} // C'est un tableau
b := a[1:] // C'est un slice, qui pointe vers le tableau original a
b[1] = 3 // Cela modifie aussi la valeur de a

Les slices seront attaché à un tableau et il est important de comprendre la distinction et l'effet que cela peut avoir lors de la manipulation des données.

Gestion des erreurs

En Javascript les erreurs se gèrent comme dans beaucoup de langages avec l'utilisation de try / catch

function MaFonction () {
  try {
    codeQuiCrash()
  } catch (e) {
    console.error('Une erreur est survenue')
  }
}

En go les fonctions peuvent avoir plusieurs valeurs en retour et cette caractéristique sera utilisée lorsqu'une opération peut rencontrer une erreur.

func MaFonction () (string, error) {
  resp, err := http.Get("https://grafikart.fr/api/posts.json")
  if err != nil {
    return "", fmt.Errorf("impossible de contacter le serveur, %w", err)
  }

  b, err := io.ReadAll(resp.Body)
    if err != nil {
    return "", fmt.Errorf("impossible de lire le contenu de la réponse, %w", err)
    }

  return string(b), nil
}

Même si ce choix finit par être assez verbeux il est intéréssant car il force les développeurs à gérer les erreurs plutôt que de les laisser remonter sans contrôle.

Gestion de l'asynchrone

En JavaScript l'asynchrone se gère au travers de fonction asynchrone qui peuvent attendre un retour de la boucle d'évènement. Pendant cette attente, JavaScript pourra s'occuper d'autres choses ce qui permet, même sur un seul thread, de pouvoir gérer plus de chose.

async function handleRequest () {
  const r = await fetch("https://grafikart.fr/api").then(r => r.json())
  console.log("response: ", r))
}
handleRequest();
console.log("Je serais affiché avant la réponse")

Go dispose d'un système de goroutine qui permet d'éxécuter une fonction sur fil séparé très léger géré par Go

func main () {
  wg := new(sync.WaitGroup)
  wg.Add(1)
  go func () {
    defer wg.Done()
    r, err := CustomHTTPGet("https://grafikart.fr/api")
    fmt.Println(r)
  }()
  fmt.Println("Je serais affiché avant la réponse")
  wg.Wait()
}

Pour communiquer avec ces goroutine, Go offre un système de channel

func main () {
  ch := make(chan string)
  go func () {
    r, err := CustomHTTPGet("https://grafikart.fr/api")
    ch <- r
  }()
  fmt.Println("Je serais affiché avant la réponse")
  fmt.Println(<- ch)
}

Les goroutines offrent beaucoup plus de possibilité mais sont aussi une source très importantes de nouveaux problèmes par rapport à ce que l'on connait en JavaScript :

  • Il faudra s'assurer que 2 goroutine n'accède pas au même espace mémoire via des mutex
  • Il faudra aussi s'assurer de ne pas laisser de goroutine tourner pour rien

Les goroutines sont aussi utilisé par défaut sur le serveur HTTP fournit par go, ce qui permet de ne pas avoir à s'en soucier la plupart du temps dans ce genre de cas d'utilisation.

Publié
Technologies utilisées
Auteur :
Grafikart
Partager