Langage Go (Golang) : définition, usages et exemples

Go est un langage de programmation compilé à typage statique, créé chez Google. Il produit un seul binaire natif, compile en quelques secondes, dispose d'un ramasse-miettes et intègre la concurrence au langage grâce aux goroutines et aux channels. Son terrain de prédilection est le logiciel côté serveur : les API, les services réseau, et les outils en ligne de commande et cloud qui les font tourner.

Voici un programme Go complet. Cliquez sur Run.

package main

import (
	"fmt"
	"strings"
)

func main() {
	languages := []string{"Go", "Python", "Rust"}

	for i, name := range languages {
		fmt.Printf("%d: %s has %d letters\n", i, name, len(name))
	}

	fmt.Println(strings.ToUpper("compiled, typed, garbage collected"))
}

Tout programme Go démarre dans package main, à func main(). := déclare une variable et en déduit le type (ici []string, une slice de chaînes). range parcourt la slice et vous donne un indice et une valeur. fmt et strings viennent de la bibliothèque standard, assez fournie pour que beaucoup de programmes n'importent rien d'autre.

Go ou Golang : le nom

Le langage s'appelle Go. « Golang » est un surnom qui vient du premier site du projet, golang.org (le site est aujourd'hui sur go.dev). Il est resté parce qu'une recherche web sur « go » renvoie tout sauf le langage. La documentation officielle dit « Go », mais « golang » est le terme que presque tout le monde tape dans un moteur de recherche, et les deux désignent la même chose. Il n'existe pas de produit ni de dialecte « Golang » distinct.

Qui a créé Go, et pourquoi

Robert Griesemer, Rob Pike et Ken Thompson ont commencé à concevoir Go chez Google en 2007. Il a été publié en open source en novembre 2009, et Go 1.0 est sorti en mars 2012.

La motivation était pratique. Les grosses bases de code C++ et Java de Google mettaient longtemps à compiler, les graphes de dépendances étaient difficiles à maîtriser, et alors que les machines multicœurs et les services en réseau étaient devenus la norme, écrire du code concurrent restait source d'erreurs. La conception de Go répond directement à ces problèmes :

• Compilation rapide. Les imports sont explicites, un import inutilisé est une erreur de compilation, et le compilateur ne réanalyse pas d'en-têtes : les gros programmes se compilent en quelques secondes.
• Langage simple. Peu de mots-clés, une seule boucle (for), pas d'héritage, pas d'exceptions. Le code écrit par des personnes différentes finit par se ressembler, ce qui facilite les revues dans une grande équipe.
• La concurrence comme fonctionnalité du langage. Lancer une tâche concurrente tient en un mot-clé, go, et les channels permettent aux tâches de communiquer.
• Déploiement simple. Le résultat est un binaire unique que vous copiez sur un serveur. Il est en général lié statiquement ; quand cgo est activé, des packages comme net peuvent se lier à la bibliothèque C du système, et CGO_ENABLED=0 désactive ce comportement.

Go 1.0 est aussi arrivé avec la promesse de compatibilité Go 1 : les programmes écrits pour Go 1.0 continuent de compiler et de s'exécuter avec les versions 1.x suivantes. En pratique, mettre à jour la chaîne d'outils casse rarement votre code, et c'est une grande raison pour laquelle les équipes font confiance à Go pour des services qui vivent longtemps.

À quoi sert Golang

Go excelle quand un programme communique sur le réseau, tourne longtemps et doit être simple à livrer :

Il convient moins aux applications de bureau graphiques, aux applications mobiles, aux front ends de navigateur et au calcul numérique ou au machine learning, où d'autres écosystèmes ont de bien meilleures bibliothèques.

Caractéristiques principales, avec du code

Types statiques avec inférence

Chaque variable a un type fixé à la compilation, mais vous l'écrivez rarement. := le déduit :

package main

import "fmt"

func main() {
	count := 3         // int
	price := 9.99      // float64
	name := "keyboard" // string
	inStock := true    // bool

	fmt.Printf("%T %T %T %T\n", count, price, name, inStock)

	total := float64(count) * price
	fmt.Printf("%d x %s = %.2f\n", count, name, total)
}

Go ne convertit jamais silencieusement entre types numériques. count * price ne compile pas, parce que l'un est un int et l'autre un float64 ; vous écrivez float64(count) vous-même. Cela élimine les troncatures silencieuses et les bugs de précision.

Les erreurs sont des valeurs

Go n'a pas d'exceptions. Une fonction qui peut échouer renvoie une error comme dernier résultat, et l'appelant la vérifie :

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"42", "forty-two"}

	for _, s := range inputs {
		n, err := strconv.Atoi(s)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("parsed:", n*2)
	}
}

Le motif if err != nil est la ligne la plus reconnaissable du code Go. Il est verbeux, et c'est voulu : chaque endroit où un programme peut échouer est visible là où cela se produit. Voir la gestion des erreurs pour envelopper et inspecter les erreurs.

Goroutines et channels

Une goroutine est une fonction qui s'exécute en concurrence avec le reste du programme. Elle coûte quelques kilo-octets de pile, donc en lancer des milliers est normal. Les channels transmettent des valeurs entre goroutines en toute sécurité :

package main

import "fmt"

func square(n int, results chan<- string) {
	results <- fmt.Sprintf("%d squared is %d", n, n*n)
}

func main() {
	results := make(chan string)

	for n := 1; n <= 3; n++ {
		go square(n, results)
	}

	for range 3 {
		fmt.Println(<-results)
	}
}

Les trois goroutines s'exécutent en concurrence, donc les trois lignes peuvent s'afficher dans n'importe quel ordre. Lancez le programme plusieurs fois et vous verrez peut-être des ordres différents. main reçoit exactement trois valeurs, il attend donc qu'elles arrivent toutes avant de se terminer.

Des interfaces sans « implements »

Un type satisfait une interface simplement en ayant les bonnes méthodes. Il n'existe pas de mot-clé implements :

package main

import (
	"fmt"
	"math"
)

type Shape interface {
	Area() float64
}

type Rect struct{ W, H float64 }
type Circle struct{ R float64 }

func (r Rect) Area() float64   { return r.W * r.H }
func (c Circle) Area() float64 { return math.Pi * c.R * c.R }

func main() {
	shapes := []Shape{Rect{W: 3, H: 4}, Circle{R: 1}}
	for _, s := range shapes {
		fmt.Printf("%T area: %.2f\n", s, s.Area())
	}
}

Rect et Circle ne mentionnent jamais Shape, et pourtant les deux peuvent être stockés dans une []Shape. Vous pouvez ainsi définir une interface dans le package qui l'utilise, bien après l'écriture des types concrets.

Une seule chaîne d'outils

La commande go fait tout : go run compile et exécute, go build produit un binaire, go test lance les tests, go fmt formate le code, go vet repère les constructions suspectes et go mod gère les dépendances. Il existe un seul style de formatage officiel, imposé par gofmt, donc les projets Go ne débattent ni des accolades ni de l'indentation.

Ce que Go laisse de côté volontairement

Certaines fonctionnalités courantes ailleurs manquent exprès :

• Pas de classes ni d'héritage. Vous utilisez des structs, des méthodes, des interfaces et l'embedding.
• Pas d'exceptions. Les erreurs sont des valeurs renvoyées. panic existe, mais il sert aux bugs, pas aux échecs ordinaires.
• Pas d'opérateur ternaire. Vous écrivez un if/else.
• Pas de mot-clé while. for couvre toutes les boucles.
• Pas de surcharge de fonctions ni d'arguments par défaut.
• Les génériques seulement depuis Go 1.18, et volontairement limités par rapport aux templates C++ ou aux génériques Java.

Les compromis, honnêtement

La verbosité. Les vérifications d'erreurs explicites et l'absence de raccourcis comme l'opérateur ternaire rendent le code Go plus long que l'équivalent en Python ou en Kotlin. Il se lit facilement ; il s'écrit en plus de lignes.

Le ramasse-miettes. Le collecteur de Go a des pauses courtes, mais cela reste un ramasse-miettes. Pour des systèmes temps réel stricts ou du code où chaque allocation compte, C, C++ ou Rust vous donnent plus de contrôle.

Les valeurs nil. Go a des pointeurs, des maps, des slices et des interfaces nil. Déréférencer un pointeur nil provoque un panic à l'exécution, et le compilateur ne l'empêche pas comme le fait le système de types de Rust.

Un système de types réduit. Pas de types somme, pas d'enums (vous les construisez avec des constantes et iota), et des génériques qui couvrent les cas courants mais pas la programmation avancée au niveau des types.

Des manques dans l'écosystème. Les bibliothèques pour les services web, les bases de données et les API cloud sont excellentes. Pour les interfaces graphiques, le calcul scientifique et le machine learning, Python, C++ ou Julia en proposent bien davantage.

Go comparé à d'autres langages

Choisissez Go quand vous voulez les performances d'un langage compilé et un déploiement simple, sans la courbe d'apprentissage de Rust ni le cérémonial de Java.

Faut-il apprendre Go ?

Si vous écrivez des services backend, des outils en ligne de commande ou quoi que ce soit dans l'infrastructure cloud, oui. Une grande partie de cet écosystème est écrite en Go, et lire son code source fait partie du métier. Le langage est petit, l'investissement est donc modeste : la syntaxe de base prend quelques jours, la concurrence et la gestion des erreurs idiomatiques quelques semaines de pratique.

Pour commencer à écrire du Go sur votre machine, installez Go, puis suivez la page hello world, qui explique chaque ligne d'un premier programme.