Conditions and loops

if / else : sans parenthèses, avec accolades

En Go, le if ressemble à ce que vous connaissez, avec deux différences qui surprennent au début : pas de parenthèses autour de la condition, et les accolades sont obligatoires, même pour une seule ligne.

age := 20

if age >= 18 {
    fmt.Println("Majeur")
} else {
    fmt.Println("Mineur")
}

// Avec else if
note := 14
if note >= 16 {
    fmt.Println("Très bien")
} else if note >= 12 {
    fmt.Println("Bien")
} else {
    fmt.Println("Peut mieux faire")
}

L'accolade ouvrante doit être sur la même ligne que le if : c'est une règle du compilateur, pas un choix de style. Le formateur gofmt impose tout le reste, donc plus de débats sur l'indentation dans les revues de code.

Majeur
Bien

if avec instruction d'initialisation

Go permet de déclarer une variable juste avant la condition, dans le if lui-même. La variable n'existe alors que dans le bloc if (et son else). C'est la forme la plus idiomatique de Go, celle que vous croiserez partout pour gérer les erreurs :

if err := faireQuelqueChose(); err != nil {
    fmt.Println("Échec :", err)
    return
}
// err n'existe plus ici : sa portée était limitée au if

Le même principe marche pour n'importe quel calcul, pas seulement les erreurs :

if reste := nombre % 2; reste == 0 {
    fmt.Println("Pair")
} else {
    fmt.Println("Impair")
}

for : la seule boucle de Go

Go n'a qu'un seul mot-clé de boucle : for. Pas de while, pas de do...while. Mais for prend plusieurs formes qui couvrent tous les besoins.

1. La forme classique (init ; condition ; incrément), comme en C ou Java :

for i := 0; i < 3; i++ {
    fmt.Println(i) // 0, 1, 2
}

2. La forme « while » : juste une condition, et c'est tout :

n := 1
for n < 10 {
    n *= 2 // 1, 2, 4, 8
}

3. La boucle infinie : aucune condition, on en sort avec break :

compteur := 0
for {
    compteur++
    if compteur == 3 {
        break // on quitte la boucle
    }
}

4. La forme range : parcourt une slice (ou une map, une chaîne...) en donnant l'index et la valeur :

fruits := []string{"pomme", "poire", "kiwi"}
for i, v := range fruits {
    fmt.Println(i, v) // 0 pomme, 1 poire, 2 kiwi
}

Si l'index ne vous intéresse pas, remplacez-le par _ (le trou noir de Go) : for _, v := range fruits.

À vous d'essayer :

package main

import "fmt"

func main() {
    // Forme classique
    for i := 0; i < 3; i++ {
        fmt.Println("classique :", i)
    }

    // Forme while
    n := 1
    for n < 10 {
        n *= 2
    }
    fmt.Println("while final :", n)

    // Forme range
    fruits := []string{"pomme", "poire", "kiwi"}
    for i, v := range fruits {
        fmt.Println("range :", i, v)
    }
}

switch : sans break, sans fallthrough

Le switch de Go corrige le piège le plus connu du C : pas besoin d'écrire break. Chaque case s'arrête tout seul. Pas de fallthrough accidentel qui exécute le case suivant par erreur.

jour := "samedi"

switch jour {
case "samedi":
    fmt.Println("Week-end !")
case "dimanche":
    fmt.Println("Week-end !")
default:
    fmt.Println("Au travail")
}

Vous pouvez regrouper plusieurs valeurs sur un même case, séparées par des virgules :

switch jour {
case "samedi", "dimanche":
    fmt.Println("Week-end !")
default:
    fmt.Println("Au travail")
}

Et le plus élégant : un switch sans condition, qui remplace avantageusement une cascade de if / else if :

note := 14
switch {
case note >= 16:
    fmt.Println("Très bien")
case note >= 12:
    fmt.Println("Bien")
default:
    fmt.Println("Peut mieux faire")
}

À vous d'essayer :

package main

import "fmt"

func main() {
    note := 14

    switch {
    case note >= 16:
        fmt.Println("Très bien")
    case note >= 12:
        fmt.Println("Bien")
    default:
        fmt.Println("Peut mieux faire")
    }

    jour := "dimanche"
    switch jour {
    case "samedi", "dimanche":
        fmt.Println("Week-end !")
    default:
        fmt.Println("Au travail")
    }
}

Récap

Trois structures de contrôle, et c'est tout ce dont Go a besoin :

• if sans parenthèses, accolades obligatoires, avec l'instruction d'init if x := f(); x != nil en réflexe quotidien.
• for : l'unique boucle, sous quatre formes (classique, while, infinie + break, et range).
• switch : pas de break, cases multiples avec virgules, et la version sans condition qui remplace les cascades de if / else if.