Quels constructs de contrôle de flux Go possède-t-il ?

Question

Accepted Answer

Le contrôle de flux de Go est volontairement **minimal** — il n'y a qu'**un seul mot-clé de boucle (`for`)**, pas de parenthèses autour des conditions, et des accolades obligatoires. Cette simplicité est intentionnelle, donnant une seule façon claire de faire chaque chose. ## if — sans parenthèses, avec une instruction init optionnelle ```go if x > 10 { // no parentheses around the condition; braces required fmt.Println("big") } else if x > 5 { fmt.Println("medium") } else { fmt.Println("small") } // if with an INIT statement — variable scoped to the if/else (very idiomatic) if err := doSomething(); err != nil { return err // `err` exists only within this if/else } ``` La forme `if init; condition` (déclarant une variable limitée à la portée du if) est extrêmement courante en Go — en particulier le modèle de vérification d'erreur `if err := ...; err != nil`. ## for — LA SEULE boucle, sous plusieurs formes ```go // 1. classic three-part for for i := 0; i < 10; i++ { ... } // 2. while-style (just a condition) for x < 100 { x *= 2 } // 3. infinite loop for { ... break ... } // loop forever until break // 4. range — iterate slices, maps, strings, channels for index, value := range mySlice { ... } for key, value := range myMap { ... } for i, char := range "héllo" { ... } // i is byte index, char is a rune for range channel { ... } ``` Go n'a **ni `while` ni `do-while`** — `for` couvre tous les besoins de boucle. La forme `range` est la façon idiomatique d'itérer sur les collections. ## switch — plus propre que C (pas de passage en cascade) ```go switch day { case "Sat", "Sun": // multiple values per case fmt.Println("weekend") case "Mon": fmt.Println("monday") // NO break needed — Go does NOT fall through by default! default: fmt.Println("weekday") } // switch with no condition = clean if/else chain switch { case score >= 90: grade = "A" case score >= 80: grade = "B" default: grade = "F" } ``` Contrairement à C/Java, le `switch` de Go **ne passe pas en cascade par défaut** (pas de `break` nécessaire) — éliminant ce bug classique. Utilisez le mot-clé `fallthrough` dans le rare cas où vous le souhaiteriez. ## defer — planifier le nettoyage ```go func readFile() { f, _ := os.Open("file.txt") defer f.Close() // runs when the function RETURNS — guaranteed cleanup // ... use f ... } ``` `defer` planifie un appel pour s'exécuter quand la fonction environnante retourne — idiomatique pour le nettoyage (fermeture de fichiers, déverrouillage de mutex). ## Pourquoi c'est important Le contrôle de flux volontairement minimal de Go reflète sa philosophie de simplicité et a des implications pratiques qu'il vaut la peine de connaître. Avoir **uniquement `for`** (couvrant les boucles classiques, de style while, infinies et range) signifie qu'il y a un seul construct de boucle cohérent — `range` étant la façon idiomatique d'itérer. La syntaxe **sans parenthèses, avec accolades obligatoires** et la forme **`if init; cond`** (en particulier `if err := ...; err != nil`) façonnent le Go idiomatique. **Le fait que `switch` ne passe pas en cascade par défaut** élimine un bug courant dans la famille C, et le `switch` sans condition est une alternative if/else propre. Et `defer` est un mécanisme de nettoyage distinctif et essentiel. Comprendre ces éléments — et comment ils diffèrent d'autres langages (une seule boucle, pas de passage en cascade, defer) — est fondamental pour lire et écrire du Go idiomatique.