Aide-mémoire Go
Dernière mise à jour
Hello World et structure d'un programme
Chaque programme Go vit dans un package ; le point d'entrée est func main dans le package main.
| Opération | Syntaxe |
|---|---|
| Déclaration de package | package main |
| Importer un package | import "fmt" |
| Importer plusieurs packages | import (\n "fmt"\n "os"\n) |
| Point d'entrée | func main() { ... } |
| Afficher une ligne | fmt.Println("Hello, World!") |
| Affichage formaté | fmt.Printf("%d items\n", n) |
| Exécuter un fichier | go run main.go |
| Construire un binaire | go build |
Variables et types
Go est typé statiquement mais peut inférer les types avec :=.
| Opération | Syntaxe |
|---|---|
| Déclarer avec le type | var age int = 30 |
| Déclarer avec inférence | var name = "Ada" |
| Déclaration courte | count := 0 |
| Plusieurs à la fois | x, y := 1, 2 |
| Constante | const Pi = 3.14 |
| Valeurs zéro | 0, "", false, nil |
| Types de base | int, float64, string, bool, byte, rune |
| Conversion de type | f := float64(i) |
Contrôle de flux
Go n'a qu'un mot-clé de boucle - for - et pas de parenthèses autour des conditions.
| Opération | Syntaxe |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If avec instruction d'init | if v, ok := m[k]; ok { ... } |
| Boucle for (style C) | for i := 0; i < 10; i++ { ... } |
| Boucle de style while | for x < 100 { ... } |
| Boucle infinie | for { ... } |
| Range sur une slice | for i, v := range items { ... } |
| Switch | switch day { case 1: ...; default: ... } |
| Switch sans expression | switch { case x > 0: ... } |
| Break / continue | break, continue |
Fonctions
Les fonctions sont des valeurs de première classe et peuvent renvoyer plusieurs résultats.
| Opération | Syntaxe |
|---|---|
| Fonction de base | func add(a int, b int) int { return a + b } |
| Type de paramètre partagé | func add(a, b int) int { ... } |
| Valeurs de retour multiples | func divmod(a, b int) (int, int) { return a / b, a % b } |
| Valeurs de retour nommées | func split(sum int) (x, y int) { x = sum / 2; return } |
| Fonction variadique | func sum(nums ...int) int { ... } |
| Fonction anonyme | f := func() { ... } |
| Fermeture | func counter() func() int { ... } |
| Defer (s'exécute au retour) | defer file.Close() |
Slices et tableaux
Les tableaux ont une taille fixe ; les slices sont des vues dynamiques sur des tableaux.
| Opération | Syntaxe |
|---|---|
| Tableau de taille fixe | var a [3]int |
| Littéral de slice | nums := []int{1, 2, 3} |
| Créer une slice | s := make([]int, 0, 10) |
| Ajouter (append) | s = append(s, 4) |
| Longueur / capacité | len(s), cap(s) |
| Extraire une sous-slice | s[1:3] |
| Copier | copy(dst, src) |
| Itérer | for i, v := range s { ... } |
Maps
Les maps sont les tables de hachage intégrées de Go.
| Opération | Syntaxe |
|---|---|
| Créer une map | m := make(map[string]int) |
| Littéral de map | m := map[string]int{"a": 1, "b": 2} |
| Définir une valeur | m["c"] = 3 |
| Obtenir une valeur | v := m["a"] |
| Vérifier l'existence | v, ok := m["x"] |
| Supprimer une clé | delete(m, "a") |
| Longueur | len(m) |
| Itérer | for k, v := range m { ... } |
Structures et méthodes
Les structures regroupent des champs ; les méthodes attachent un comportement via un récepteur.
| Opération | Syntaxe |
|---|---|
| Définir une structure | type Point struct { X, Y int } |
| Créer une instance | p := Point{X: 1, Y: 2} |
| Accéder à un champ | p.X |
| Pointeur vers une structure | p := &Point{1, 2} |
| Méthode à récepteur valeur | func (p Point) Dist() float64 { ... } |
| Méthode à récepteur pointeur | func (p *Point) Move(dx int) { p.X += dx } |
| Structure embarquée | type Circle struct { Point; R int } |
| Tags de structure | Name string avec un tag json:"name" entre backticks |
Interfaces
Les interfaces sont satisfaites implicitement - tout type ayant les bonnes méthodes convient.
| Opération | Syntaxe |
|---|---|
| Définir une interface | type Shape interface { Area() float64 } |
| Implémenter (implicite) | func (c Circle) Area() float64 { ... } |
| Interface vide (any) | var x interface{} ou var x any |
| Assertion de type | s, ok := x.(string) |
| Switch de type | switch v := x.(type) { case int: ... } |
| Interface Stringer | func (p Point) String() string { ... } |
Goroutines et canaux
Les goroutines sont des threads légers ; les canaux font passer des valeurs entre elles.
| Opération | Syntaxe |
|---|---|
| Démarrer une goroutine | go doWork() |
| Créer un canal | ch := make(chan int) |
| Canal tamponné | ch := make(chan int, 5) |
| Envoyer vers un canal | ch <- 42 |
| Recevoir d'un canal | v := <-ch |
| Fermer un canal | close(ch) |
| Range sur un canal | for v := range ch { ... } |
| Select sur des canaux | select { case v := <-ch: ...; default: ... } |
| Groupe d'attente | var wg sync.WaitGroup; wg.Add(1); wg.Wait() |
| Mutex | var mu sync.Mutex; mu.Lock(); mu.Unlock() |
Gestion des erreurs
Go renvoie les erreurs comme des valeurs - il n'y a pas d'exceptions.
| Opération | Syntaxe |
|---|---|
| Renvoyer une erreur | func read() (string, error) { return "", err } |
| Vérifier une erreur | if err != nil { return err } |
| Créer une erreur | errors.New("not found") |
| Erreur formatée | fmt.Errorf("bad id %d", id) |
| Envelopper une erreur | fmt.Errorf("load: %w", err) |
| Désencapsuler / comparer | errors.Is(err, os.ErrNotExist) |
| Comparer par type | errors.As(err, &target) |
| Panic / recover | defer func() { recover() }() |
La syntaxe Go que vous utilisez le plus, sur une seule page. Cet aide-mémoire Go est une référence rapide pour le cœur du langage - variables et types, slices et maps, structures et interfaces, plus les goroutines et les canaux qui font briller le Golang en matière de concurrence.
Tout ce qui figure ici est du Go standard et se compile avec la chaîne d'outils officielle. Copiez ce dont vous avez besoin, ou essayez chaque extrait en direct dans le playground Go - aucune installation requise.
FAQ de l'aide-mémoire Go
Cet aide-mémoire Go est-il gratuit ?
Oui. Cet aide-mémoire Go est entièrement gratuit, sans inscription. Mettez-le en favori et revenez dès que vous devez retrouver une opération sur les slices, un schéma de canal ou une méthode de structure.
Quelle est la différence entre := et var en Go ?
var x = 0 déclare une variable et fonctionne partout, y compris au niveau du package. x := 0 est la déclaration courte de variable : elle déclare et affecte à la fois, infère le type, et ne peut être utilisée qu'à l'intérieur d'une fonction. Utilisez var quand vous avez besoin d'un type explicite ou d'une variable de niveau package, et := pour des déclarations locales concises.Que sont les goroutines et les canaux ?
Une goroutine est un thread léger géré par le runtime Go - vous en démarrez une en écrivant
go someFunc(). Les canaux sont des tuyaux typés qui permettent aux goroutines de communiquer en toute sécurité : une goroutine envoie avec ch <- v et une autre reçoit avec <-ch. Ensemble, ils forment le modèle de concurrence central de Go, résumé par l'adage « partagez la mémoire en communiquant ».Puis-je m'entraîner à Go en ligne ?
Oui. Ouvrez le playground Go pour exécuter n'importe quel extrait de cet aide-mémoire dans votre navigateur - aucune chaîne d'outils Go à installer. Quand vous voulez de la structure, le cours Go interactif gratuit de Coddy vous emmène des variables et des slices jusqu'aux goroutines et aux canaux, étape par étape.
Cet aide-mémoire convient-il aux débutants ?
Oui. Il est organisé des sujets les plus courants (variables, contrôle de flux, fonctions) jusqu'aux plus avancés (goroutines, canaux, gestion des erreurs), pour que vous puissiez utiliser les premières sections dès le premier jour et progresser vers le reste.
Ressources connexes
Plus d'aide-mémoires
