Précédent

Suivant

Parcourir les données avec des expressions for

Effectué

Un autre flux de contrôle commun est une boucle. Go utilise une seule construction de bouclage et il s’agit d’une boucle for. Toutefois, vous pouvez représenter des boucles de plusieurs façons. Dans cette partie, vous découvrirez les modèles de boucle pris en charge par Go.

Syntaxe de base de la boucle for

Comme les instructions if et switch, les expressions de boucle for ne nécessitent pas de parenthèses. Cependant, les accolades sont obligatoires.

Les points-virgules (;) séparent les trois composants des boucles for :

• Une instruction initiale qui est exécutée avant la première itération (facultatif).
• Expression de condition qui est évaluée avant chaque itération. La boucle s’arrête lorsque cette condition est false.
• Une post-instruction qui est exécutée à la fin de chaque itération (facultatif).

Comme vous pouvez le voir, la boucle for dans Go est similaire à la boucle for dans les langages de programmation tels que C, Java et C#.

Dans sa forme la plus simple, une boucle for dans Go ressemble à ceci :

func main() {
    sum := 0
    for i := 1; i <= 100; i++ {
        sum += i
    }
    fmt.Println("sum of 1..100 is", sum)
}

Voyons comment vous pouvez écrire des boucles dans Go.

Pré-instructions et post-instructions vides

Dans certains langages de programmation, vous utilisez le mot clé while pour écrire des modèles de boucle où seule l’expression de condition est requise. Go n’a pas de mot clé while. Mais vous pouvez utiliser une boucle for à la place et profiter du fait que Go rend les pré-instructions et les post-instructions facultatives.

Utilisez l’extrait de code suivant pour confirmer que vous pouvez utiliser la boucle for sans utiliser les pré-instructions et les post-instructions.

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    var num int64
    rand.Seed(time.Now().Unix())
    for num != 5 {
        num = rand.Int63n(15)
        fmt.Println(num)
    }
}

Tant que la variable num contient une valeur différente de 5, le programme imprime un nombre aléatoire.

Boucles infinies et instructions d’arrêt

Un autre modèle de boucle que vous pouvez écrire dans Go est la boucle infinie. Dans ce cas, vous n’écrivez ni d’expression de condition, ni de pré-instruction, ni de post-instruction. Au lieu de cela, vous écrivez votre façon de sortir de la boucle. Si vous ne le faites pas, la logique ne se fermera jamais. Pour que la logique quitte une boucle, utilisez le mot clé break.

Pour écrire une boucle infinie correcte, suivez le mot clé for avec des accolades, comme suit :

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    var num int32
    sec := time.Now().Unix()
    rand.Seed(sec)

    for {
        fmt.Print("Writing inside the loop...")
        if num = rand.Int31n(10); num == 5 {
            fmt.Println("finish!")
            break
        }
        fmt.Println(num)
    }
}

Chaque fois que vous exécutez ce code, vous recevez une sortie différente.

Instructions continues

Dans Go, vous pouvez utiliser le mot clé continue pour ignorer l’itération actuelle d’une boucle. Vous pouvez utiliser ce mot clé, par exemple, pour exécuter une validation avant la poursuite de la boucle. Vous pouvez aussi l’utiliser lorsque vous écrivez une boucle infinie et que vous devez attendre qu’une ressource devienne disponible.

Cet exemple utilise le mot clé continue :

package main

import "fmt"

func main() {
    sum := 0
    for num := 1; num <= 100; num++ {
        if num%5 == 0 {
            continue
        }
        sum += num
    }
    fmt.Println("The sum of 1 to 100, but excluding numbers divisible by 5, is", sum)
}

Cet exemple a une boucle for qui itère de 1 à 100, en ajoutant le nombre actuel à la somme de chaque itération. Chaque nombre divisible par 5 est ignoré dans l’itération actuelle de la boucle, et n’est pas ajouté à la somme.

Continuer