Les boucles dans le langage de programmation Go

Ce chapitre vous explique les boucles en GoLang. Les boucles permettent d'itérer un bloc de code plusieurs fois. On apprendra à utiliser la boucle for avec les mots-clés break et continue dans le langage de programmation Go.

Description

Une boucle est un moyen d'exécuter un bloc de code plusieurs fois, suivant le résultat d’une condition ou selon un nombre d'itérations connu à l'avance.

Information

Une itération correspond à un tour de boucle

Boucle for

Pour déclarer une boucle il suffit d'utiliser le mot-clé for.

Il existe deux types de boucle for, soit vous connaissez au préalable le nombre d'itérations (par exemple vous savez dès le début qu'un bloc de code va s'exécuter x fois) ou inversement vous n'avez aucune idée du nombre d'itérations de votre bloc de code.

Vous connaissez déjà le nombre d'itérations

Voici comment on déclare une boucle quand vous connaissez antérieurement le nombre d'itérations :

for initialisation ; condition ; itération {
    /* le code qui sera répété */
}

initialisation est une instruction exécutée avant le premier parcours de la boucle for c'est là-bas qu'on initialise le compteur de la boucle (le compteur est une variable temporaire qui est détruite à la sortie de la boucle) suivit d'une condition du compteur dont la valeur déterminera la fin de la boucle, l'itération est l'opération qui déterminera le nombre de répétitions de votre bloc de code.

Imaginez le scénario suivant : "Vous êtes jeune, fainéant et mauvais élève (pas bien !). Votre professeur vous demande alors d'écrire 100 fois la phrase suivante "Je ne dois frapper mes camarades de classe". ça tombe vous êtes en train de suivre un cours sur les boucles 😉 !"

package main

import (
    "fmt"
)

func main() {
    for compteur := 0; compteur < 100; compteur++ {
        fmt.Println(compteur + 1, ") Je ne dois frapper mes camarades de classe")
    }
}

Résultat :

1 ) Je ne dois taper mes camarades de classe
2 ) Je ne dois taper mes camarades de classe
...
99 ) Je ne dois taper mes camarades de classe
100 ) Je ne dois taper mes camarades de classe

Vous ne connaissez pas le nombre d'itérations

Voici comment on déclare une boucle quand vous ne connaissez pas à l'avance le nombre d'itérations :

for condition {
    /* le code qui sera répété */
}

Si la condition est vraie alors on reste dans la boucle sinon on quitte la boucle.

Imaginez le scénario suivant : "Un videur de boîte de nuit refuse l'entrée des mineurs"

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    var age int

    for age < 18 { // on quitte la boucle s'il est majeur
        fmt.Print("Entrez votre age : ")
        scanner.Scan()
        age, _ = strconv.Atoi(scanner.Text())
    }

    fmt.Println("Bienvenue en boite de nuit !")
}

Résultat :

Entrez votre age : 17
Entrez votre age : 19
Bienvenue en boite de nuit

break et continue

Pour manipuler vos boucles infinies il peut être intéressant d'utiliser les deux mots-clés suivants :

  • break : Interrompre une boucle
  • continue : Revenir au début de la boucle

Imaginons le scénario suivant : "Vous avez bien envie de jouer à un jeu hasard mais le problème c'est que vous n'avez pas assez d'argent 😢 par contre vous avez votre compilateur go 😉."

Vous n'avez pas d'argent ? Pas de panique les boucles infinies vont vous aider à sortir de cette crise !

package main

import (
    "bufio"
    "fmt"
    "math/rand"
    "os"
    "strconv"
    "time"
)

func main() {

    rand.Seed(time.Now().UnixNano())
    randomInt := rand.Intn(10)

    scanner := bufio.NewScanner(os.Stdin)

    max := 20

    for true { // boucle infinie
        fmt.Print("Entrez votre nombre : ")
        scanner.Scan()
        nbr, err := strconv.Atoi(scanner.Text())

        if err != nil {
            fmt.Println("Entrez un nombre !")
            continue // on revient au début de la boucle
        }
        if nbr > max || nbr < 0 {
            fmt.Println("Votre nombre doit être compris entre 0 et ", max, " !")
            continue
        } else if nbr == randomInt {
            fmt.Println("Bien joué !")
            break // on quitte la boucle
        } else {
            fmt.Println("Dommage !")
        }
    }
}

Résultat :

Entrez votre nombre : 50
Votre nombre doit être compris entre 0 et  20  !
Entrez votre nombre : arnaque
Entrez un nombre !
Entrez votre nombre : 6
Dommage !
Entrez votre nombre : 15
Dommage !
Entrez votre nombre : 3
Bien joué !

Espace commentaire

Écrire un commentaire

Rejoignez la discussion

Vous devez être connecté pour poster un message.

18 commentaires

Nickel les exemples de boucles

27/04/19 à 14:24
alix-alves
Membre actif
Avatar de alix-alves
alix-alves
Membre actif

Bonne description des boucles Go

26/04/19 à 00:24

Le break et continue c'est la vie pour le contrôle de flux dans les pipelines

Ça rend le code beaucoup plus robuste face aux événements imprévus

23/04/19 à 19:44
celine06
Membre actif
Avatar de celine06
celine06
Membre actif

La distinction entre for "avec" et "sans" nombre d'itérations est vraiment utile

21/04/19 à 15:28
gbrunet
Membre
Avatar de gbrunet
gbrunet
Membre

Merci pour le rappel sur continue

19/04/19 à 02:29
xavier-diaz
Membre
Avatar de xavier-diaz
xavier-diaz
Membre

Indispensable le break pour nos boucles infinies de supervision

18/04/19 à 00:07

La section sur les boucles for est complète

15/04/19 à 03:17
mhuet
Membre
Avatar de mhuet
mhuet
Membre

J'ai utilisé votre exemple pour "vous ne connaissez pas le nombre d'itérations" pour un worker en continu

Ça tourne comme un charme sans consommer de CPU inutilement

13/04/19 à 22:50
nath06
Membre actif
Avatar de nath06
nath06
Membre actif

Continue est top pour skipper des éléments non pertinents

11/04/19 à 21:08
kfaivre
Membre actif
Avatar de kfaivre
kfaivre
Membre actif

Le break est indispensable pour sortir rapidement d'une boucle si une condition est remplie

10/04/19 à 04:26
rblondel
Membre
Avatar de rblondel
rblondel
Membre

les boucles for sont la colonne vertébrale des scripts de nettoyage de logs

07/04/19 à 19:10
zoe47
Membre actif
Avatar de zoe47
zoe47
Membre actif

La description des boucles est pile ce qu'il fallait pour débuter

04/04/19 à 20:54

super clair la distinction entre nombre d'itérations connu ou non

Ça simplifie la conception des routines de polling sur nos services

03/04/19 à 13:23

le "break et continue" c'est vital pour la gestion des erreurs dans les boucles de traitement

02/04/19 à 12:48
vcaron
Membre
Avatar de vcaron
vcaron
Membre

Boucle for en Go c'est super direct merci

01/04/19 à 09:06

Très intéressant! Mais une question subsiste : dans le dernier TP, on écrit :

  randomInt := rand.Intn(10)
max := 20   

D'après ce que je comprends, la première ligne génère un nombre aléatoire entre 0 &amp; 10, dans la seconde ligne, on définit un max à 20, qui ne sera donc jamais atteint. Ne serait-il pas mieux de faire ainsi de cette manière :

  max := 20
randomInt := rand.Intn(max)   

Petites update à faire cependant : L'usage de Seed est dépréciée d'après ce que j'ai lu, donc on peut l'enlever

30/03/19 à 12:21
ajdaini-hatim
Membre rédacteur secouriste actif
Avatar de ajdaini-hatim
ajdaini-hatim
Membre rédacteur secouriste actif

@tina-arouna merci !

28/03/19 à 03:14
tina-arouna
Membre
Avatar de tina-arouna
tina-arouna
Membre

cool

26/03/19 à 02:27

Rejoindre la communauté

Recevoir les derniers articles gratuitement en créant un compte !

S'inscrire