Les boucles For en Golang

Introduction

Contrairement à d'autres langages, Go ne possède que le mot-clé "for" pour les instructions de boucle. Cependant, il est à la fois efficace et flexible. Découvrons ensemble le fonctionnement de la boucle for en Go.

Points de connaissances :

• Boucle For
• Boucle For range

Caractères dans une chaîne de caractères

Dans la section précédente sur les structures de données de base, nous avons appris qu'une chaîne de caractères (string) est une collection de caractères. Par conséquent, nous pouvons utiliser l'index pour récupérer des caractères spécifiques dans une chaîne. Créons un fichier string.go et écrivons-y le code suivant :

cd ~/project
touch string.go

package main

import "fmt"

func main() {
    s := "labex"

    // Access each character in the string using indices
    fmt.Println(s[0], s[1], s[2], s[3], s[4])
    // Print characters
    fmt.Printf("%c %c %c %c %c\n", s[0], s[1], s[2], s[3], s[4])
}

Exécutez le programme :

go run string.go

Le résultat est le suivant :

108 97 98 101 120
l a b e x

Dans ce programme, nous déclarons une variable de type chaîne pour stocker "labex" et utilisons l'index pour accéder à chaque caractère. Lors de l'affichage, nous constatons que le programme affiche des nombres au lieu des caractères réels.

En comparant avec la table ASCII suivante, nous pouvons voir que les nombres correspondent aux caractères réels. Par exemple, dans la table ASCII, "108" correspond à "l".

Cela s'explique par le fait que les caractères stockent en réalité l'encodage numérique de chaque caractère sous le format "UTF-8". Le "UTF-8" étant compatible avec l'"ASCII", l'emplacement du caractère "l" stocke en fait la valeur numérique "108".

Si nous voulons afficher les caractères eux-mêmes, nous pouvons utiliser la fonction fmt.Printf avec la séquence d'échappement %c. C'est ce qui est démontré dans la deuxième ligne du code. Elle convertit l'encodage numérique en caractères avant de les afficher.

Pour accéder à chaque caractère de la chaîne dans le fichier string.go, nous devons déclarer un index à chaque fois. Cela devient fastidieux lorsqu'on traite des centaines ou des milliers de données. Dans ce cas, nous pouvons utiliser une boucle for pour automatiser l'opération.

Syntaxe de la boucle For

Une boucle exécute un bloc de code en fonction d'une condition. Examinons la syntaxe de l'instruction de boucle for :

for initialization; condition; post {
    // code block
}

L'instruction d'initialisation initialise une variable. La condition doit retourner une valeur booléenne. L'instruction post modifie la valeur de la variable à chaque itération de la boucle. Regardons un exemple concret.

Créez un fichier for.go dans le répertoire ~/project et écrivez le contenu suivant :

cd ~/project
touch for.go

package main

import "fmt"

func main() {
    // Output numbers from 0 to 9
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }
}

Exécutez le programme :

go run for.go

Le résultat est le suivant :

0
1
2
3
4
5
6
7
8
9

Dans ce programme, nous initialisons d'abord une variable temporaire i à 0. À chaque itération, la valeur de i est augmentée de 1. La condition spécifie que la boucle continue tant que la valeur de i est inférieure à 10, ce qui signifie que le programme affichera les nombres de 0 à 9.

Remarque : Dans une boucle for, l'initialisation, la condition et l'instruction post sont toutes facultatives. Cela signifie que même sans ces instructions, la boucle for peut fonctionner.

Si seule l'instruction de condition est présente, la boucle for fonctionne de manière similaire à une boucle "while" dans d'autres langages.

Le code suivant utilise uniquement la condition pour obtenir le même résultat que le programme précédent :

package main

import "fmt"

func main() {
    i := 0
    for i < 10 {
        fmt.Println(i)
        i++
    }
}

Vous remarquerez que lorsque seule la condition est présente, les points-virgules ; utilisés pour séparer les instructions peuvent être omis.

Utilisation de la boucle For

Maintenant que nous comprenons la syntaxe de la boucle for, réécrivons le premier programme string.go en utilisant une boucle.

package main

import "fmt"

func main() {
    s := "labex"
    for i := 0; i < len(s); i++ {
        fmt.Printf("%d %c\n", int(s[i]), s[i])
    }
}

Exécutez le programme :

go run string.go

Le résultat est le suivant :

108 l
97 a
98 b
101 e
120 x

Exercice

Faisons un petit exercice pour consolider votre compréhension de la boucle for.

Créez un fichier for2.go. La tâche consiste à afficher chaque caractère de la chaîne "labex" dans l'ordre inverse.

Résultat attendu :

x
e
b
a
l

Contraintes :

• Le fichier for2.go doit être placé dans le répertoire ~/project.
• Utilisez une boucle for pour obtenir le résultat.

Indice : L'index commence à 0.

Le mot-clé "break"

Dans la section précédente, nous avons mentionné que les trois instructions d'une boucle for sont facultatives. Que se passerait-il si aucune d'entre elles n'était déclarée ? Testons cela.

Écrivez le code suivant dans le fichier for.go :

package main

import "fmt"

func main() {
    for {
        fmt.Printf("1")
    }
}

Exécutez le programme :

go run for.go

On constate que si la condition n'est pas déclarée, elle est considérée comme true par défaut et la boucle s'exécute indéfiniment.

Astuce : Utilisez Ctrl+C pour arrêter le programme.

Si nous voulons quitter la boucle sous une condition spécifique sans avoir déclaré de condition initiale, ou si nous ne pouvons pas écrire de condition simple, nous pouvons utiliser le mot-clé "break". Il force la sortie immédiate de la boucle parente.

Mettez à jour le fichier for.go avec le code suivant, qui utilise le mot-clé "break" pour afficher 23 fois le chiffre "1" :

package main

import "fmt"

func main() {
    i := 0
    for {
        // Increment the value of i by 1 in each loop iteration
        i++
        fmt.Printf("1")
        // Exit the loop when the value of i is 23
        if i == 23 {
            break
        }
    }
}

Le mot-clé "break" ne s'utilise pas uniquement dans les boucles sans condition ; il peut aussi être utilisé dans une boucle for classique. Lorsque la condition du "break" est remplie, il ignore la condition de la boucle et interrompt l'exécution.

Le mot-clé "continue"

En plus du mot-clé "break" qui force la sortie de la boucle, il existe le mot-clé "continue". Celui-ci permet de sauter le reste de l'itération actuelle et de passer immédiatement à l'itération suivante.

L'utilisation de "continue" est similaire à celle de "break", mais leurs fonctions diffèrent radicalement.

Mettons à jour le fichier for.go pour ignorer les chiffres 2 et 8 :

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 2 || i == 8 {
            continue
        }
        fmt.Println(i)
    }
}

Exécutez le programme :

go run for.go

Le résultat est le suivant :

0
1
3
4
5
6
7
9

Dans ce programme, nous avons ajouté une structure conditionnelle à l'intérieur du bloc de la boucle for. Si la valeur actuelle de la variable de boucle est 2 ou 8, le programme ignore le reste du code (l'affichage) et entame l'itération suivante. C'est pourquoi les chiffres 2 et 8 n'apparaissent pas dans la sortie.

Résumé

Dans ce lab, nous avons exploré la boucle for. Voici ce qu'il faut retenir :

• Les trois paramètres de la boucle for sont facultatifs.
• Le mot-clé break permet de quitter prématurément la boucle en cours.
• Le mot-clé continue permet de sauter l'itération actuelle pour passer directement à la suivante.