Boucles for en Golang

Introduction

Contrairement à d'autres langages, Go ne dispose que du mot-clé "for" pour les instructions de boucle. Cependant, il est efficace et flexible. Apprenons-en plus sur la boucle for en Go.

Points clés de connaissance :

• 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 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 de caractères. Créons un fichier string.go et écrivons le code suivant dedans :

cd ~/project
touch string.go

package main

import "fmt"

func main() {
    s := "labex"

    // Accéder à chaque caractère dans la chaîne de caractères en utilisant les indices
    fmt.Println(s[0], s[1], s[2], s[3], s[4])
    // Afficher les caractères
    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

La sortie est la suivante :

108 97 98 101 120
l a b e x

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

En comparant 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é le codage numérique de chaque caractère sous l'encodage "UTF-8". "UTF-8" est compatible avec "ASCII", donc la position du caractère "l" stocke en réalité le codage numérique "108".

Si nous voulons afficher des caractères, nous pouvons utiliser la fonction fmt.Printf avec la séquence d'échappement %c pour les afficher sous forme de caractères. Cela est démontré dans la deuxième ligne du code. Elle convertira le codage numérique en caractères puis les affichera.

Pour accéder à chaque caractère dans la chaîne de caractères du fichier string.go, nous devons déclarer un index à chaque fois. Cela sera fastidieux lorsqu'il s'agit de traiter des centaines ou des milliers de données. Dans ce cas, nous pouvons utiliser une boucle for pour effectuer l'opération.

Syntaxe de la boucle for

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

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

La déclaration d'initialisation initialise une variable. La condition doit renvoyer une valeur booléenne. La déclaration post modifie la valeur de la variable à chaque itération de la boucle. Examinons 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() {
    // Afficher les nombres de 0 à 9
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }
}

Exécutez le programme :

go run for.go

La sortie est la suivante :

0
1
2
3
4
5
6
7
8
9

Dans ce programme, nous initialisons d'abord une variable temporaire i à 0, et à chaque itération de la boucle, la valeur de i sera augmentée de 1. La condition est que la boucle continuera 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, les déclarations d'initialisation, de condition et post sont toutes facultatives. Cela signifie que même sans ces déclarations, la boucle for fonctionnera normalement.

Si seule la déclaration 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 déclaration de 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 pouvez voir que lorsque seule la déclaration de condition est présente, le point-virgule ; utilisé pour séparer les déclarations peut ê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 for.

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

La sortie est la suivante :

108 l
97 a
98 b
101 e
120 x

Quiz

Faisons un quiz pour consolider notre compréhension de la boucle for.

Créez un fichier for2.go. L'objectif est d'afficher chaque caractère de la chaîne de caractères "labex" dans l'ordre inverse.

Sortie attendue :

x
e
b
a
l

Exigences :

• 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'elles n'était déclarée? Faisons une expérience.

É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

Nous pouvons constater que si la condition dans la boucle for n'est pas déclarée, la condition sera considérée comme true et la boucle s'exécutera indéfiniment.

Conseil : Utilisez Ctrl+C pour terminer le programme.

Si nous voulons sortir de la boucle dans une condition spécifiée sans déclarer d'instruction de condition ou si nous ne pouvons pas écrire d'instruction de condition, nous pouvons utiliser le mot-clé "break". Il force la sortie immédiate de la boucle englobante.

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

package main

import "fmt"

func main() {
    i := 0
    for {
        // Incrémenter la valeur de i de 1 à chaque itération de la boucle
        i++
        fmt.Printf("1")
        // Sortir de la boucle lorsque la valeur de i est 23
        if i == 23 {
            break
        }
    }
}

Le mot-clé "break" peut non seulement être utilisé dans une boucle for sans instruction de condition, mais il peut également être utilisé dans une boucle for avec une instruction de condition. Lorsque la condition "break" est remplie, il saute l'instruction de condition et sort de la boucle.

Le mot-clé "continue"

En plus du mot-clé "break", qui force la sortie immédiate de la boucle, il existe également le mot-clé "continue", qui vous permet de sauter le reste de l'itération de boucle actuelle et de commencer la prochaine itération.

L'utilisation du mot-clé "continue" est similaire à celle du mot-clé "break", mais leurs fonctions sont différentes.

Mettons à jour le fichier for.go pour sauter les nombres 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

La sortie est la suivante :

0
1
3
4
5
6
7
9

Dans ce programme, nous avons ajouté une instruction conditionnelle dans le bloc de code de la boucle for. Si la valeur actuelle de la variable de boucle est 2 ou 8, elle saute le reste du code et commence la prochaine itération de boucle. Par conséquent, la sortie n'inclut pas les nombres 2 et 8.

Résumé

Dans ce laboratoire, nous avons appris à utiliser la boucle for. Revoyons rapidement :

• Les trois paramètres de la boucle for sont facultatifs.
• Le mot-clé break peut être utilisé pour sortir de la boucle actuelle.
• Le mot-clé continue peut être utilisé pour sauter l'itération actuelle et commencer la suivante.