L'instruction conditionnelle if-else

En Go, la structure if se distingue par une syntaxe épurée : les parenthèses autour de la condition sont facultatives, mais les accolades pour délimiter les blocs de code sont obligatoires. Une contrainte syntaxique forte impose que l'accolade ouvrante { soit située sur la même ligne que le mot-clé if ou else.

// Structure simple
if x > 10 {
    fmt.Println("Valeur élevée")
}

// Structure complète
if score >= 90 {
    fmt.Println("Excellent")
} else if score >= 60 {
    fmt.Println("Passable")
} else {
    fmt.Println("Échec")
}

Une fonctionnalité puissante de Go est la possibilité d'exécuter une instruction d'initialisation juste avant l'évaluation de la condition. Les variables déclarées dans cette phase ont une portée limitée au bloc if-else.

func verifierStock(id int) {
    // Initialisation de 'qte' avant le test de condition
    if qte := consulterBDD(id); qte > 0 {
        fmt.Printf("Stock disponible : %d\n", qte)
    } else {
        fmt.Println("Rupture de stock")
    }
}

Le commutateur switch

Le switch en Go est plus flexible que dans de nombreux langages hérités du C. Par défaut, il s'arrête après l'exécution d'un cas (case) sans nécessiter de mot-clé break. De plus, il peut évaluer n'importe quel type de données ou même des expressions complexes.

func evaluerType(v interface{}) {
    switch t := v.(type) {
    case int:
        fmt.Println("C'est un entier")
    case string:
        fmt.Println("C'est une chaîne")
    default:
        fmt.Printf("Type inconnu : %T\n", t)
    }
}

Si vous souhaitez poursuivre l'exécution vers le cas suivant, vous devez utiliser explicitement le mot-clé fallthrough.

etat := 1
switch etat {
case 1:
    fmt.Println("Phase 1 terminée")
    fallthrough
case 2:
    fmt.Println("Exécution de la phase 2")
default:
    fmt.Println("Nettoyage")
}

Boucles et itérations avec for

Go simplifie les structures itératives en n'utilisant qu'un seul mot-clé : for. Ce dernier remplace à la fois le for classique, le while et le foreach.

Itération classique (compteur)

for index := 0; index < 5; index++ {
    fmt.Printf("Itération n°%d\n", index)
}

Simulation du while

En omettant l'initialisation et la progression, le for se comporte come un while.

compteur := 10
for compteur > 0 {
    compteur--
}

Boucle infinie

Une boucle sans condition est une boucle infinie, souvent utilisée avec un select ou une sortie explicite.

for {
    if conditionDeSortie() {
        break
    }
    traiterDonnees()
}

Itération sur des collections (for-range)

Pour parcourir des tableaux, des slices ou des maps, l'utilisation de range est privilégiée. Elle retourne l'index (ou la clé) et la valeur de chaque élément.

nombres := []int{10, 20, 30}
for i, v := range nombres {
    fmt.Printf("Position %d : Valeur %d\n", i, v)
}

Contrôle de flux : break et continue

Ces instructions permettent de modifier le comportement des boucles :

• break : Interrompt immédiatement la boucle la plus interne ou sort d'un bloc switch.
• continue : Ignore les instructions restantes dans l'itération actuelle et passe directement à l'évaluation de la condition suivante de la boucle.