Documentation Go
Référence Go concise et illustrée par des exemples. Lisez le concept, voyez le code, puis pratiquez-le dans un parcours Coddy.
Commencer un parcours guidé en GoPour commencer
- Qu'est-ce que Go ?Go (souvent appelé Golang) est un langage compilé à typage statique, conçu chez Google pour écrire des serveurs et des outils rapides et fiables. Cette page explique ce qu'il est, à quoi il sert et où il montre ses limites.
- Installer GoComment télécharger et installer Go sur Windows, macOS et Linux, vérifier l'installation avec go version, comprendre GOPATH, et corriger l'erreur « go: command not found ».
- Hello WorldLe programme hello world en Go ligne par ligne : package main, le bloc import, func main et fmt.Println, plus comment l'exécuter et les erreurs de compilation que rencontrent d'abord les débutants.
- go run et go buildCe que font go run, go build et go install, comment Go nomme le binaire, comment compiler pour une autre plateforme avec GOOS et GOARCH, et les vérifications go fmt et go vet à lancer avant de committer.
- Modules GoComment fonctionnent les modules Go : en créer un avec go mod init, choisir un chemin de module, ajouter des dépendances avec go get, faire le ménage avec go mod tidy, à quoi sert go.sum, et replace pour le développement local.
- Packages et importsComment fonctionnent les packages Go : la clause package, importer des packages standard et de modules, noms exportés ou non exportés, répartir un package sur plusieurs fichiers, packages internal, alias d'import, imports blancs, et l'erreur « undefined » de go run main.go.
Les bases
- VariablesComment déclarer des variables en Go avec var et la forme courte :=, ce que sont les valeurs zéro, l'affectation multiple, et les erreurs de masquage et de variable inutilisée qui piègent les nouveaux développeurs Go.
- ConstantesComment fonctionne const en Go : déclarer des constantes, la différence entre constantes typées et non typées, les expressions constantes à précision arbitraire, et pourquoi Go n'a pas de slices, maps ou structs constantes.
- Enums et iotaGo n'a pas de mot-clé enum. Cette page montre le remplacement idiomatique : un type nommé plus un bloc const avec iota, et comment ajouter String(), la validation, le parsing, des flags binaires et le support JSON.
- Types de donnéesLes types intégrés de Go : tailles et plages des entiers, float32 et float64, bool, string, byte et rune, nombres complexes, valeurs zéro, et comment afficher le type d'une valeur avec %T.
- Conversion de typesComment convertir entre types en Go : int en string et string en int avec strconv, flottants en entiers, conversions numériques avec T(v), octets et runes, le piège de string(65), et la gestion des erreurs de conversion.
- ChaînesTravailler avec les chaînes en Go : le package strings (Split, Join, Contains, Replace, Fields, TrimSpace, ToUpper), construire des chaînes efficacement avec strings.Builder, les chaînes brutes multilignes, l'immuabilité, et pourquoi len compte les octets.
- Runes et octetsCe que signifient rune et byte en Go, comment les chaînes stockent l'UTF-8, pourquoi len compte les octets, comment range décode les runes, les conversions entre string, []byte et []rune, et le package bytes.
- fmt.Printf et SprintfComment le package fmt de Go affiche et formate des valeurs : Println, Printf, Sprintf et Errorf, le tableau complet des verbes de format (%v, %+v, %d, %s, %q, %f, %T, %w et d'autres), largeur, précision et remplissage.
Structures de contrôle
- if / elseComment fonctionnent if, else if et else en Go : pas de parenthèses, accolades obligatoires, le if avec clause d'initialisation et sa portée, l'idiome if err != nil, et les retours anticipés au lieu d'imbrications profondes.
- Boucle forGo n'a qu'un seul mot-clé de boucle, for, et il couvre tout : la boucle compteur à trois clauses, la boucle while à condition seule, la boucle infinie, et range sur des slices, maps, chaînes, channels, entiers et fonctions. Plus break et continue avec étiquette, et le changement des variables de boucle de Go 1.22.
- Boucle whileGo n'a pas de mot-clé while. Une boucle for avec seulement une condition est la boucle while de Go, for sans condition est une boucle infinie, et un do-while est une boucle infinie avec le test à la fin.
- Boucles rangeCe que for range fournit pour les slices, tableaux, chaînes, maps, channels, entiers et fonctions itérateurs, pourquoi la variable valeur est une copie, ce qui se passe quand vous modifiez une slice ou une map pendant le parcours, et le range sur des fonctions de Go 1.23.
- Instruction switchComment fonctionne switch en Go : les cas ne s'enchaînent pas par défaut, un cas peut lister plusieurs valeurs, un switch sans condition remplace les chaînes if/else, le switch avec instruction d'initialisation, le mot-clé fallthrough, et un aperçu des type switches.
- Opérateur ternaireGo n'a pas d'opérateur ternaire (cond ? a : b). Cette page explique pourquoi, montre le remplacement idiomatique par if/else, cmp.Or pour les valeurs par défaut, et une fonction utilitaire générique avec le piège qui la distingue d'un vrai ternaire.
Fonctions
- FonctionsComment déclarer et appeler des fonctions en Go : paramètres, types de paramètres partagés, valeurs de retour, passage par valeur, et fonctions en tant que valeurs que l'on stocke et que l'on passe.
- Valeurs de retour multiplesLes fonctions Go peuvent renvoyer plusieurs valeurs. Cette page couvre la syntaxe, la convention (value, error), l'idiome comma-ok, les résultats nommés, les retours nus et l'identifiant blanc.
- Fonctions variadiquesUne fonction Go variadique accepte un nombre quelconque d'arguments finaux d'un même type. Découvrez la syntaxe ...T, comment passer une slice avec s..., le piège du partage, et comment fmt.Println utilise ...any.
- ClosuresEn Go, les fonctions anonymes peuvent capturer des variables de la portée qui les entoure. On obtient ainsi des closures : compteurs, générateurs, middlewares et callbacks qui gardent leur propre état.
- Instruction deferdefer programme un appel qui s'exécute au retour de la fonction englobante. Découvrez l'ordre LIFO, le moment où les arguments sont évalués, la fermeture de fichiers et le déverrouillage de mutex, defer dans les boucles, et la modification des résultats nommés.
- MéthodesUne méthode est une fonction avec un receveur. Apprenez à déclarer des méthodes, à choisir entre receveur valeur et receveur pointeur, les ensembles de méthodes et les interfaces, et les méthodes sur des types qui ne sont pas des structs.
Collections
- TableauxUn tableau Go a une longueur fixe qui fait partie de son type, et il est copié à l'affectation. Apprenez à déclarer, parcourir, comparer et passer des tableaux, et pourquoi la plupart du code Go utilise des slices à la place.
- SlicesLes slices sont le type liste du quotidien en Go. Découvrez make, append et la croissance, len et cap, comment le découpage partage le tableau sous-jacent (et le bug que cela provoque), copy, le package slices, les slices 2D, et nil ou vide.
- MapsLes maps Go stockent des paires clé-valeur avec une recherche rapide. Apprenez à les créer, à tester l'existence d'une clé avec comma-ok, à supprimer, à parcourir (dans un ordre aléatoire), à trier les clés, à stocker des structs, et à éviter les panics de map nil et d'écritures concurrentes.
- EnsemblesGo n'a pas de type ensemble intégré. L'idiome standard est une map avec des valeurs struct vides. Découvrez l'ajout, le test d'appartenance et la suppression, l'union, l'intersection et la différence, et comment écrire un petit Set générique.
- TriTriez des slices en Go avec slices.Sort et slices.SortFunc, triez des structs selon un ou plusieurs champs avec cmp.Compare, gardez l'ordre des éléments égaux avec un tri stable, et lisez l'ancien code sort.Slice.
Structs, interfaces et génériques
- StructsLes structs regroupent des champs nommés dans un seul type. Apprenez à les définir et à les initialiser, les valeurs zéro, les pointeurs vers des structs, les structs anonymes, la comparaison, les struct tags et la convention du constructeur NewX.
- PointeursUn pointeur contient l'adresse d'une valeur. Découvrez & et *, new, les pointeurs vers des structs, pourquoi vous pouvez renvoyer sans risque un pointeur vers une variable locale, quand utiliser des pointeurs, et le panic de déréférencement d'un pointeur nil.
- InterfacesLes interfaces Go sont satisfaites implicitement : tout type qui a les bonnes méthodes les implémente. Découvrez les petites interfaces comme io.Reader et fmt.Stringer, l'interface vide any, le piège de l'interface nil, et le principe « acceptez des interfaces, renvoyez des structs ».
- Embedding de structsL'embedding place un type dans un autre sans nom de champ, si bien que ses champs et ses méthodes sont promus vers le type extérieur. Découvrez comment fonctionne la promotion, l'embedding d'interfaces, les conflits de noms, et pourquoi l'embedding n'est pas de l'héritage.
- Assertions de typeUne assertion de type récupère la valeur concrète contenue dans une interface. Découvrez x.(T), la forme comma-ok qui ne provoque jamais de panic, l'assertion vers une autre interface, les type switches, et errors.As pour les erreurs enveloppées.
- GénériquesLes génériques (Go 1.18+) permettent à une fonction ou à un type de fonctionner avec de nombreux types tout en restant sûrs au niveau du typage. Découvrez les paramètres de type, les contraintes any, comparable et cmp.Ordered, les contraintes personnalisées avec ~, les types génériques, et quand ne pas les utiliser.
Erreurs
- Gestion des erreursGo traite les erreurs comme des valeurs ordinaires renvoyées par les fonctions. Découvrez l'interface error, if err != nil, errors.New et fmt.Errorf, renvoyer des erreurs avec du contexte, les vérifier avec errors.Is et errors.As, et traiter chaque erreur une seule fois.
- Erreurs personnaliséesDéfinissez des erreurs sentinelles et des types d'erreur personnalisés, enveloppez les erreurs avec %w, vérifiez-les avec errors.Is et errors.As, combinez-en plusieurs avec errors.Join, et écrivez des méthodes Unwrap et Is quand vous en avez besoin.
- panic et recoverUn panic arrête l'exécution normale et déroule la pile en exécutant les appels différés. Découvrez ce qui provoque les panics, comment recover dans une fonction différée en arrête un, les messages d'erreur d'exécution que vous verrez, et quand paniquer est le bon choix.
Concurrence
- GoroutinesComment exécuter des fonctions en concurrence avec le mot-clé go, attendre qu'elles se terminent, récupérer leurs résultats, et éviter les data races, les fuites et les plantages que les goroutines rendent faciles.
- ChannelsComment les channels Go transmettent des valeurs entre goroutines : channels avec et sans buffer, fermeture et range, types directionnels, l'erreur de deadlock, et un pipeline construit avec eux.
- Instruction selectComment select attend plusieurs opérations de channel à la fois : le choix parmi les cas prêts, les envois et réceptions non bloquants avec default, les timeouts avec time.After, et l'arrêt des boucles avec un channel d'arrêt ou un context.
- WaitGroupComment sync.WaitGroup attend la fin d'un ensemble de goroutines : les règles d'Add, Done et Wait, pourquoi il doit être passé par pointeur, la collecte des résultats et des erreurs, et un pool de workers construit dessus.
- MutexComment protéger un état partagé entre goroutines avec sync.Mutex et sync.RWMutex, quand sync/atomic suffit, comment sync.Once exécute une initialisation exactement une fois, et les erreurs de verrouillage qui causent des deadlocks.
- Package contextComment context.Context transporte l'annulation, les échéances et les valeurs liées à une requête dans un programme Go : Background, WithCancel, WithTimeout, WithValue, ctx.Done dans un select, et le context dans les serveurs et clients HTTP.
Bibliothèque standard
- Package timeComment manipuler les dates et les heures en Go : time.Now et time.Sleep, l'arithmétique des Duration, la disposition de référence 2006-01-02 15:04:05 pour Format et Parse, les fuseaux horaires, les timestamps Unix, et les timers et tickers.
- JSONComment encoder et décoder du JSON en Go avec encoding/json : Marshal et Unmarshal, les struct tags comme omitempty et omitzero, l'affichage indenté, le décodage dans map[string]any, le refus des champs inconnus, et la lecture en flux avec Decoder.
- Lire et écrire des fichiersComment lire et écrire des fichiers en Go : os.ReadFile et os.WriteFile, la lecture ligne par ligne avec bufio.Scanner, l'ajout en fin de fichier avec os.OpenFile, vérifier si un fichier existe, et travailler avec des répertoires.
- Serveur HTTPComment construire un serveur web avec le package standard net/http de Go : handlers, routage ServeMux avec méthodes et jokers de chemin (Go 1.22), réponses JSON, codes de statut, middlewares, timeouts et arrêt propre.
- Client HTTPComment faire des requêtes HTTP en Go avec net/http : http.Get, lire et fermer le body, vérifier les codes de statut, les timeouts de http.Client, les requêtes avec context et en-têtes, les paramètres de requête, et envoyer du JSON en POST.
- Arguments de ligne de commandeComment un programme Go lit sa ligne de commande : os.Args, le package flag pour des options typées, les sous-commandes avec FlagSet, les variables d'environnement avec os.Getenv et os.LookupEnv, et les codes de sortie avec os.Exit.
- Expressions régulièresComment utiliser les expressions régulières en Go avec le package regexp : MustCompile, MatchString, FindString et FindAllString, groupes de capture et groupes nommés, ReplaceAllString, et les limites de la syntaxe RE2 comme l'absence de lookbehind.
- LogsComment journaliser en Go : le package log classique avec ses flags et log.Fatal, et log/slog (Go 1.21) pour des logs structurés avec niveaux, attributs clé-valeur, handlers texte et JSON, et des loggers qui transportent du contexte avec With.
Tests et structure de projet
- TestsComment tester du code Go avec le package standard testing et go test : fichiers _test.go, fonctions TestXxx, t.Errorf ou t.Fatalf, tests pilotés par tableau avec t.Run, helpers et répertoires temporaires, couverture, benchmarks avec b.Loop, et tests d'exemple.
- Structure de projetComment organiser un projet Go : commencer à plat, découper en packages quand il y a une raison, utiliser cmd/ pour plusieurs binaires et internal/ pour le code que personne d'autre ne doit importer, bien nommer les packages, et garder les tests à côté du code.
