Glossaire Go

Un conduit typé pour envoyer et recevoir des valeurs entre goroutines.

Un channel se crée avec make(chan T). L’envoi (ch <- v) et la réception (v := <-ch) synchronisent les goroutines. Un channel non bufferisé bloque jusqu’à ce qu’un émetteur et un récepteur soient prêts, ce qui en fait un outil de synchronisation autant que de communication.

                ch := make(chan int)
              

L’interface intégrée utilisée pour signaler qu’une opération a échoué.

error est une interface avec une seule méthode Error() string. En Go, les erreurs sont des valeurs renvoyées explicitement, généralement en dernier retour d’une fonction, et vérifiées avec if err != nil. On enrichit une erreur avec fmt.Errorf et %w.

                if err != nil { return err }
              

Voir : La gestion des erreurs en Go

L’outil officiel qui formate automatiquement le code Go.

gofmt applique un style canonique unique à tout le code Go, ce qui met fin aux débats de formatage. La commande go fmt exécute gofmt sur un package. Le code présenté sur LearnGoLab est formaté avec gofmt.

                gofmt -w main.go
              

Voir : Votre premier programme Go

Une fonction exécutée de façon concurrente, gérée par le runtime de Go.

Une goroutine est lancée avec le mot-clé go. Elle est beaucoup plus légère qu’un thread système : le runtime de Go en multiplexe des milliers sur un petit nombre de threads. Les goroutines communiquent généralement via des channels plutôt qu’en partageant de la mémoire.

                go processTask(id)
              

Un ensemble de signatures de méthodes qu’un type peut satisfaire implicitement.

En Go, une interface est satisfaite dès qu’un type possède toutes les méthodes requises : il n’y a pas de mot-clé implements. L’interface vide interface{} (ou any) est satisfaite par tout type. Les interfaces favorisent un code découplé et testable.

                type Reader interface { Read(p []byte) (int, error) }
              

Voir : Les interfaces en Go, Les structs et les méthodes en Go

Une table associant des clés à des valeurs.

Une map se crée avec make(map[K]V) ou un littéral. L’accès à une clé absente renvoie la valeur zéro du type ; la forme value, ok := m[k] permet de distinguer l’absence d’une valeur zéro. Les maps ne sont pas sûres pour un accès concurrent en écriture.

                ages := map[string]int{"Ada": 36}
              

Voir : Les maps en Go

Une valeur qui contient l’adresse mémoire d’une autre valeur.

&x donne l’adresse de x ; *p déréférence le pointeur p. Go n’a pas d’arithmétique de pointeurs et son ramasse-miettes gère la mémoire. Les pointeurs servent surtout à partager et modifier une valeur sans la copier.

                p := &value
              

Voir : Les structs et les méthodes en Go

Une vue redimensionnable sur un tableau sous-jacent.

Un slice décrit un segment d’un tableau via un pointeur, une longueur et une capacité. append peut faire croître un slice, en réallouant le tableau sous-jacent si nécessaire. Les slices sont la structure de séquence la plus utilisée en Go.

                nums := []int{1, 2, 3}
              

Voir : Les tableaux et les slices en Go

Un type composite regroupant des champs nommés.

Un struct rassemble des données liées. On peut lui attacher des méthodes via un récepteur. Les structs sont copiés par valeur ; pour modifier un struct dans une méthode, on utilise un récepteur pointeur.

                type Point struct { X, Y int }
              

Voir : Les structs et les méthodes en Go

La valeur par défaut donnée à une variable déclarée sans initialisation.

Chaque type a une valeur zéro : 0 pour les nombres, "" pour string, false pour bool, nil pour les pointeurs, slices et maps. Grâce à elle, il n’existe pas de variable non initialisée en Go.

                var count int // 0
              

Voir : Les variables et les types en Go