1 Aperçu des instructions de boucle

En langage Go, les instructions de boucle nous permettent d'exécuter un bloc de code plusieurs fois. Lorsque vous avez besoin d'effectuer certaines opérations de manière répétée, les instructions de boucle deviennent très utiles. Par exemple, vous voudrez peut-être itérer à travers chaque élément d'un tableau, ou répéter une opération jusqu'à ce qu'une condition spécifique soit remplie. En Go, les instructions de boucle sont principalement mises en œuvre en utilisant le mot-clé for, qui est la seule instruction de boucle dans le langage Go. L'utilisation correcte des instructions de boucle est cruciale pour écrire un code efficace et maintenable.

2 Bases de la boucle for

2.1 Structure de la boucle for

La boucle for en langage Go se compose de trois parties :

  1. Instruction d'initialisation : exécutée avant la première itération, généralement utilisée pour déclarer un compteur de boucle.
  2. Expression de condition : évaluée avant chaque itération. Si la condition est vraie, le corps de la boucle est exécuté.
  3. Instruction de post-traitement : exécutée après le bloc de code de chaque itération, généralement utilisée pour mettre à jour le compteur de boucle.

La syntaxe de la boucle for est la suivante :

for instruction d'initialisation; expression de condition; instruction de post-traitement {
    // code du corps de la boucle
}

2.2 Exemple simple de la boucle for

Comprenons le processus d'exécution de la boucle for à travers un exemple simple :

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Println("La valeur de i est :", i)
    }
}

Dans cet exemple, la variable i est initialisée à 0. La boucle for vérifie si la condition i < 5 est vraie. Si la condition est vraie, le corps de la boucle est exécuté et la valeur de i est imprimée. Après avoir exécuté le corps de la boucle, la valeur de i est mise à jour par i++ (opération d'incrémentation), puis la boucle revérifie la condition jusqu'à ce que la valeur de i atteigne 5, moment auquel la condition devient fausse et la boucle for se termine.

2.3 Autres exemples de boucles for

La boucle for en langage Go est très flexible et peut être écrite sous différentes formes pour gérer différentes situations.

2.3.1 Boucle infinie

En Go, vous pouvez omettre l'instruction d'initialisation, l'expression de condition et l'instruction de post-traitement de la boucle for, créant ainsi une boucle infinie qui s'exécutera jusqu'à ce qu'elle soit terminée par une instruction break ou une valeur de retour d'une fonction.

for {
    // Code à l'intérieur d'une boucle infinie
    if certaineCondition {
        break // Sortir de la boucle lorsque certaine condition est remplie
    }
}

2.3.2 Boucle avec seulement une condition

En Go, vous pouvez également utiliser une boucle for qui ne contient qu'une condition, similaire à une boucle while dans d'autres langages de programmation.

n := 0
for n < 5 {
    fmt.Println(n)
    n++
}

Le code ci-dessus va imprimer 0 à 4, et la boucle se terminera lorsque n atteindra 5.

2.3.3 Boucler à travers un tableau ou une tranche

En Go, le mot-clé range est utilisé pour simplifier l'itération à travers chaque élément d'un tableau ou d'une tranche.

elements := []int{1, 2, 3, 4, 5}
for index, valeur := range elements {
    fmt.Printf("Index : %d, Valeur : %d\n", index, valeur)
}

Le code ci-dessus va imprimer l'index et la valeur de chaque élément. Si vous avez seulement besoin de la valeur des éléments, vous pouvez utiliser _ pour ignorer l'index.

for _, valeur := range elements {
    fmt.Printf("Valeur : %d\n", valeur)
}

Remarque : L'utilisation des tableaux sera expliquée en détail dans les chapitres suivants. Si vous ne comprenez pas cette partie, ce n'est pas grave tant que vous comprenez que la boucle for peut être utilisée de cette manière.

2.3.4 Boucler à travers les maps

Lorsqu'on itère à travers une map, la combinaison de la boucle for et de l'expression range est très puissante. Cela vous permet d'obtenir chaque paire clé-valeur de la map.

couleurs := map[string]string{"rouge": "#ff000", "vert": "#00ff00", "bleu": "#000ff"}
for cle, valeur := range couleurs {
    fmt.Printf("Clé : %s, Valeur : %s\n", cle, valeur)
}

Dans cet exemple, nous imprimerons toutes les clés et leurs valeurs correspondantes dans la map couleurs. Tout comme pour l'itération à travers des slices, si vous avez seulement besoin de la clé ou de la valeur, vous pouvez choisir d'ignorer l'autre.

Remarque : L'utilisation des maps sera expliquée en détail dans les chapitres suivants. Si vous ne comprenez pas cette partie, ce n'est pas grave tant que vous comprenez que la boucle for peut être utilisée de cette façon.

3 Contrôler le flux des boucles

3.1 Utiliser break pour terminer une boucle

Parfois, nous devons sortir de la boucle prématurément lorsqu'une condition spécifique est rencontrée, et dans ce cas, l'instruction break peut être utilisée. Voici un exemple d'utilisation de break pour sortir d'une boucle :

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            break // Sortir de la boucle lorsque i est égal à 5
        }
        fmt.Println("La valeur de i est :", i)
    }
    // La sortie ne contiendra que des valeurs de 0 à 4
}

3.2 Utiliser continue pour sauter les itérations

Dans certaines situations, nous pouvons vouloir sauter l'itération courante et passer à l'itération suivante dans la boucle. Cela peut être réalisé en utilisant l'instruction continue. Voici un exemple :

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i%2 != 0 {
            continue // Sauter cette itération si i est impair
        }
        fmt.Println("Nombre pair :", i)
    }
}