Introduction

Le contrôle de flux détermine l'ordre d'exécution des instructions dans un programme. Go propose plusieurs mécanismes de contrôle :

• Conditions avec if/else
• Branchements via switch/case
• Boucles utilisant for et range
• Sauts d'instructions avec goto

Structures conditionnelles

Les conditions Go utilisent une syntaxe sans parenthèses. Voici la structure générale :

if condition {
    // bloc à exécuter
} else if autre_condition {
    // bloc alternatif
} else {
    // cas par défaut
}

Exemple concret avec gestion de notes :

resultat := 78
switch {
case resultat >= 90:
    fmt.Println("Mention : Excellent")
case resultat >= 80:
    fmt.Println("Mention : Très Bien")
case resultat >= 70:
    fmt.Println("Mention : Bien")
default:
    fmt.Println("Mention : Passable")
}

Règles importantes

• Les accolades sont obligatoires même pour un bloc vide
• L'accolade ouvrante doit être sur la même ligne que le mot-clé
• On peut déclarer une varible dans la condition : if val := calc(); val > 10 {

Instructions switch

Le switch Go évite le fallthrough par défaut. On peut comparer des valeurs ou des expressions :

jour := "mardi"
switch jour {
case "lundi", "mardi", "mercredi", "jeudi", "vendredi":
    fmt.Println("Jour ouvré")
case "samedi", "dimanche":
    fmt.Println("Week-end")
}

Fonctionnalités avancées

Le mot-clé fallthrough force l'exécution du case suivant :

num := 1
switch {
case num == 1:
    fmt.Println("Un")
    fallthrough
case num == 2:
    fmt.Println("Deux")
}

Affiche :

Un
Deux

Règles du switch

• Pas besoin de break implicite
• On peut lister plusieurs valeurs avec des virgules
• Un switch sans expression agit comme une chaîne de if/else

Boucles

Go utilise exclusivement for pour les itérations. Voici différentes formes :

Boucle classique

total := 0
for compteur := 1; compteur <= 50; compteur++ {
    total += compteur
}
fmt.Println("Somme de 1 à 50:", total)

Boucle conditionnelle

taux := 1.0
iteration := 0
for taux > 0.001 {
    taux = taux * 0.8
    iteration++
}
fmt.Println("Itérations nécessaires:", iteration)

Boucle infinie

var tentatives int
for {
    tentatives++
    if tentatives >= 10 {
        break
    }
    // Traitement
}

Parcours avec range

elements := []string{"Go", "Python", "Rust"}
for index, valeur := range elements {
    fmt.Printf("Index %d: %s\n", index, valeur)
}

Instructions goto

Le saut inconditionnel peut simplifier certains flux complexes :

func traitementDonnees() {
    for x := 0; x < 5; x++ {
        for y := 0; y < 5; y++ {
            if x*y > 10 {
                goto finTraitement
            }
            // Traitement normal
        }
    }
finTraitement:
    fmt.Println("Traitement interrompu")
}

Bonnes pratiques

• Utiliser des labels explicites avec goto
• Privilégier break avec label pour sortir de boucles imbriquées
• Déclarer les variables de contrôle de boucle dans le for