Le langage Go
Partie 2 sur 4
4Premiers pas
Après installation de Go, on crée un projet, appelé module, avec la commande go mod init, qui produit un fichier go.mod décrivant le module et ses dépendances. Le programme minimal s’écrit ainsi :
package main
import "fmt"
func main() {
fmt.Println("Bonjour, le monde !")
}
Chaque fichier appartient à un paquet (package) ; le paquet main et sa fonction main marquent le point de départ d’un programme. On l’exécute directement avec go run . ou on produit un fichier exécutable avec go build. La compilation est si rapide qu’on a l’impression d’utiliser un langage interprété.
5Les bases du langage
5.1Variables et types
On déclare une variable avec var, ou, à l’intérieur d’une fonction, avec l’opérateur :=, qui déduit le type de la valeur. Toute variable non initialisée reçoit une valeur zéro bien définie : 0 pour un nombre, la chaîne vide pour un texte, false pour un booléen. Il n’y a donc jamais de variable au contenu aléatoire, contrairement au C.
var ville string // vaut "" au départ age := 30 // int, déduit de la valeur prix := 9.5 // float64 actif := true // bool const TVA = 0.20 // constante
Le compilateur refuse les variables déclarées mais jamais utilisées, et les paquets importés pour rien : une rigueur qui surprend au début, mais qui garde le code propre.
5.2Tranches, tables et boucles
Les deux structures de données les plus utilisées sont les tranches (en anglais slices), des listes de taille variable, et les tables (map), qui associent des clés à des valeurs (voir les structures de données). Go n’a qu’une seule instruction de boucle, for, qui couvre tous les usages :
notes := []int{12, 7, 15}
notes = append(notes, 18)
capitales := map[string]string{"France": "Paris", "Gabon": "Libreville"}
for i, n := range notes {
fmt.Println(i, n)
}
for pays, capitale := range capitales {
fmt.Println(pays, ":", capitale)
}
5.3Fonctions et erreurs
Une fonction peut renvoyer plusieurs valeurs. Par convention, la dernière est une erreur, de type error, qui vaut nil (« rien ») quand tout s’est bien passé. Le code qui appelle la fonction vérifie l’erreur immédiatement :
f, err := os.Open("config.txt")
if err != nil {
return fmt.Errorf("ouverture de la configuration : %w", err)
}
defer f.Close() // sera exécuté à la sortie de la fonction
Le motif if err != nil, qui revient à chaque appel susceptible d’échouer, est la critique la plus fréquente adressée à Go : il allonge le code. Ses défenseurs y voient une qualité : chaque erreur est traitée là où elle se produit, de façon visible. Le mot-clé defer programme une action, comme la fermeture d’un fichier, pour la fin de la fonction, quelle que soit la façon dont on en sort : on ne l’oublie plus.
5.4Structures et méthodes
Une struct regroupe des champs ; on lui associe des méthodes. Go n’a pas de mots-clés public ou private : un nom qui commence par une majuscule est visible depuis les autres paquets, un nom en minuscule reste interne. Go a des pointeurs, notés * et & comme en C, mais sans arithmétique : on ne peut pas les déplacer dans la mémoire, ce qui supprime une grande source d’erreurs (voir les pointeurs).
type Compte struct {
Titulaire string
solde float64 // minuscule : interne au paquet
}
func (c *Compte) Deposer(montant float64) error {
if montant <= 0 {
return errors.New("montant invalide")
}
c.solde += montant
return nil
}
5.5Des interfaces implicites
Une interface décrit un ensemble de méthodes. Particularité de Go, un type n’a pas besoin de déclarer qu’il implémente une interface : il suffit qu’il possède les méthodes demandées. Cette souplesse permet d’utiliser un type avec une interface définie bien après lui, dans un autre paquet (voir la programmation orientée objet).
type Forme interface {
Aire() float64
}
type Rect struct{ L, H float64 }
func (r Rect) Aire() float64 { return r.L * r.H }
var f Forme = Rect{L: 3, H: 2} // Rect est une Forme, sans le déclarer
La bibliothèque standard en fait un usage constant : tout type qui possède une méthode Read est un io.Reader, qu’il s’agisse d’un fichier, d’une connexion réseau ou d’un texte en mémoire, et peut être passé à toutes les fonctions qui lisent des données.
5.6La généricité
Pendant dix ans, Go n’a pas eu de généricité : impossible d’écrire une seule fonction Max valable pour les entiers et les nombres à virgule. Après de longues discussions, Go 1.18 l’a introduite en 2022, sous une forme volontairement limitée : des paramètres de type, entre crochets, contraints par des interfaces.
func Max[T int | float64](a, b T) T {
if a > b {
return a
}
return b
}
Max(3, 7) // 7
Max(2.5, 1.5) // 2.5
Les développeurs Go l’utilisent avec modération, surtout pour les fonctions utilitaires sur les tranches et les tables, que la bibliothèque standard propose désormais dans les paquets slices et maps.
Pour s’exercer
Exercice 1 : deux résultats
Écrivez une fonction Diviser(a, b float64) qui renvoie le quotient et une erreur si b est nul, puis montrez comment l’appeler.
Voir la réponse
func Diviser(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("division par zéro")
}
return a / b, nil
}
q, err := Diviser(10, 4)
if err != nil {
log.Println("erreur :", err)
return
}
fmt.Println(q) // 2.5
La signature annonce clairement que l’opération peut échouer. Ignorer l’erreur reste possible, en écrivant q, _ := Diviser(10, 0), mais cela se voit à la lecture, et l’outil go vet ou des vérificateurs complémentaires le signalent.
Exercice 2 : la tranche partagée
Qu’affiche ce programme ? Pourquoi ?
a := []int{1, 2, 3}
b := a
b[0] = 9
fmt.Println(a)
Voir la réponse
Il affiche [9 2 3]. Une tranche n’est pas le tableau lui-même, mais une petite structure qui désigne un tableau sous-jacent, avec une longueur et une capacité. L’affectation b := a copie cette structure, pas le tableau : a et b désignent les mêmes cases. Pour obtenir une copie indépendante, on écrit b := slices.Clone(a). Ce comportement, source d’erreurs fréquentes, est à connaître avant de passer des tranches à des fonctions qui les modifient.
Exercice 3 : le compteur qui se trompe
Ce programme lance mille goroutines qui incrémentent chacune un compteur. Pourquoi affiche-t-il souvent moins de 1000 ? Comment le détecter et le corriger ?
compteur := 0
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
compteur++
}()
}
wg.Wait()
fmt.Println(compteur)
Voir la réponse
compteur++ n’est pas une opération indivisible : il faut lire la valeur, ajouter 1, puis écrire le résultat. Si deux goroutines lisent la même valeur en même temps, l’une des deux incrémentations est perdue : c’est une course de données. Lancé avec go run -race, le programme affiche un rapport « DATA RACE » qui désigne la ligne fautive. Pour corriger, on protège l’opération par un verrou, var mu sync.Mutex puis mu.Lock(); compteur++; mu.Unlock(), ou on utilise un compteur atomique, var compteur atomic.Int64 et compteur.Add(1).
Exercice 4 : une interface sans le dire
On définit type Cercle struct{ R float64 }. Que faut-il ajouter pour qu’un Cercle soit utilisable comme une Forme, au sens de la section 5.5 ? Faut-il modifier l’interface ?
Voir la réponse
Il suffit de définir la méthode func (c Cercle) Aire() float64 { return math.Pi * c.R * c.R }. Aucune déclaration du type « Cercle implémente Forme » n’est nécessaire, et l’interface n’a pas à être modifiée, ni même à connaître l’existence de Cercle. Si la méthode manque ou a une signature différente, le compilateur le signale à l’endroit où l’on utilise un Cercle comme une Forme.