Tutoriel Golang For Loop [Avec exemples]

Apprenez tout sur les boucles for Golang en codant plusieurs exemples utiles.

Récemment, des langages de programmation tels que Rust, Golang et TypeScript sont devenus très populaires parmi les développeurs. Si vous êtes intéressé par le développement back-end et DevOps, vous devriez considérer apprendre Golang est une excellente option !

Si vous êtes un débutant et que vous apprenez les bases d'un langage de programmation, la construction de boucles est l'un des premiers concepts que vous devez comprendre.

Golang ne fournit que la construction de la boucle for. Nous en apprendrons plus sur les boucles for et sur la manière d'émuler d'autres boucles à l'aide de la boucle for.

Commençons !

Syntaxe de la boucle For de Golang

Dans Golang, vous pouvez créer une boucle for en utilisant la syntaxe suivante :

for initialization; condition; update {
    // do something
}

Ici,

l'initialisation indique l'initialisation de la variable de bouclage.
condition est la condition de bouclage qui détermine l'exécution du corps de la boucle. Tant que la condition de bouclage est évaluée comme étant vraie, les instructions du corps de la boucle sont exécutées. Lorsque la condition devient fausse, le contrôle quitte la boucle.
mise à jour indique la mise à jour de la variable de bouclage, généralement une incrémentation ou une décrémentation.

💡 Remarquez que cette boucle est similaire à la boucle for en C, mais sans les parenthèses.

Voici le flux de contrôle dans les boucles de Golang :

Il est temps de coder quelques exemples!⏰ Pour coder, vous pouvez soit utiliser une installation locale de Golang, soit exécuter les exemples sur Go Playground.

Exemples de boucles en Golang

Utilisons la syntaxe que nous venons d'apprendre pour écrire notre première boucle for. Voici une simple boucle for qui imprime les nombres de 1 à 5 par pas de un.

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		fmt.Println(i)
	}
}

Nous initialisons la variable de bouclage i à 1, fixer la condition à i <= 5et incrémente la variable de bouclage de un après chaque itération. Voici le résultat :

//Output
For loop:
1
2
3
4
5

Écrivons une autre boucle for. Cette boucle part de 5 et compte jusqu'à 1 ; elle continue jusqu'à ce que la variable de bouclage soit supérieure ou égale à 1. Nous décrémentons donc la variable de bouclage de un après chaque itération.

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := num; i >= 1; i-- {
		fmt.Println(i)
	}
}

Et nous obtenons le résultat escompté :

//Output
For loop:
5
4
3
2
1

Quelle est la portée de la variable de bouclage ?

La portée de la variable de bouclage est limitée au bloc de la boucle for et n'est pas accessible en dehors de la boucle.

Pour le vérifier, essayons d'accéder à la valeur de la variable de bouclage i en dehors de la boucle :

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		fmt.Println(i)
	}
	fmt.Println(i)

}

Comme prévu, nous rencontrons l'erreur suivante i est indéfinie (et sa portée est limitée à la boucle for) :

// Output
./prog.go:11:14: undefined: i

Boucle infinie For dans Golang

Peut-on avoir des boucles infinies en Go ? Oui, c'est tout à fait possible !

Si vous regardez le flux de contrôle de la boucle for :

Le corps de la boucle continuera à s'exécuter tant que la condition sera évaluée comme étant vraie.
Lorsque la condition devient fausse, le contrôle sort de la boucle.
Ainsi, si la condition ne devient jamais fausse (ou est toujours vraie), nous avons une boucle infinie.

Mais vous pouvez également utiliser la boucle for sans l'initialisation, la condition et la mise à jour, sans rencontrer d'erreurs de syntaxe. Ainsi, si vous pouvez faire tourner la boucle à l'infini même en utilisant une construction de boucle for comme celle-ci :

package main

import "fmt"

func main() {
	for {
	   fmt.Println("running...")
	}
}

//Output
running...
running...
running...
running...
running...
//and it goes on forever!

Dans cet exemple, nous définissons la variable num à 5. Et la condition de bouclage est num >= 5. La boucle fonctionne donc tant que num est supérieur ou égal à zéro.

package main

import "fmt"

func main() {
	num := 5
	for num > 0 {
		fmt.Println(num)
	}
}

Parce que la valeur de num ne change jamais, la condition est toujours évaluée à vrai, et la boucle s'exécute à l'infini !

//Output
5
5
5
5
5
5
//and it goes on forever!

Golang n'ayant que la construction de la boucle for, nous pouvons essayer d'émuler les boucles while et boucles "do-while en utilisant des boucles for. Apprenons donc à le faire !

Emulation de la boucle While à l'aide de la boucle For

La boucle while prend généralement la forme suivante :

// initialize looping var
while (condition){
    // do something
    // update looping var
}

Si vous vous souvenez, dans la première infini boucle for que nous avons écrite : nous avons utilisé la boucle for suivante - sans l'initialisation, la condition et la mise à jour.

for {
// the simplest infinite loop
}

Nous pouvons donc modifier la boucle for pour qu'elle contienne seulement les condition (sous la forme suivante) pour émuler la boucle while :

//initialize looping var
for condition {
 // do something
 // update looping var
}

Voici l'équivalent en boucle while de la première boucle for que nous avons écrite :

package main

import "fmt"

func main() {
	fmt.Println("Emulating while loop")
	num := 5
	for num > 0 {
		fmt.Println(num)
		num--
	}
}

//Output
Emulating while loop
5
4
3
2
1

Emulation de la boucle Do-While à l'aide de la boucle For

Si vous avez codé dans un langage comme le C, vous savez que la construction de la boucle do-while prend la forme suivante :

// initialize looping var
do {
//something
// update looping var
} while(condition);

La principale différence entre les boucles while et do while est que la boucle while vérifie la condition sur entrée dans la boucle. La boucle "do-while", quant à elle, vérifie la condition lors de l'entrée dans la boucle. sortie de la boucle.

Ainsi, dans une boucle while, si la condition est évaluée à faux, le corps de la boucle ne s'exécute jamais. En revanche, dans une boucle do-while, le corps de la boucle s'exécute même si la condition est évaluée à faux.

En utilisant ces informations, nous pouvons émuler le comportement d'une boucle "do-while" :

Écrire une boucle infinie
Utilisez une instruction conditionnelle if avec la condition correcte pour sortir de la boucle.

Supposons que vous souhaitiez écrire une boucle "do-while" dans laquelle la condition d'exécution du corps de la boucle est la suivante num < 0. Vous pouvez donc écrire une boucle for et sortir de la boucle si num >= 0.

package main

import "fmt"

func main() {
	fmt.Println("Emulating do-while loop")
	num := 5
	for {
		fmt.Println("loop runs...")
		if num >= 0 {
			break
		}
	}
}

💡 Notez que l'exécution de la boucle si num < 0 et sortir de la boucle si num >= 0 sont des conditions équivalentes.

Bien que la condition num > 0 est initialement fausse (num est 5), le corps de la boucle s'exécute une fois, émulant une boucle do-while.

//Output
Emulating do-while loop
loop runs...

Boucler à travers des tableaux en utilisant la boucle For

Boucler à travers des tableaux - Utiliser pour boucler

Lorsque l'on parcourt des tableaux dans Golang à l'aide d'une boucle for et de la fonction rangevous pouvez accéder à les deux les indices et les éléments. Le fonctionnement est similaire à celui de la fonction Fonction d'énumération en Python.

Ici, nous créons numArrayun tableau d'entiers. Et le parcourir à l'aide d'une boucle for :

package main

import "fmt"

func main() {
	fmt.Println("Looping through an array")
	numArray := []int{3, 7, 0, 10, 8, 9}
	for idx, num := range numArray {
		fmt.Println("At index", idx, ": ", num)
	}
}

Comme nous l'avons vu, nous pouvons accéder simultanément à l'index et à l'élément à chaque index :

//Output
Looping through an array
At index 0 :  3
At index 1 :  7
At index 2 :  0
At index 3 :  10
At index 4 :  8
At index 5 :  9

Utilisation de defer dans la boucle For de Golang

Dans Golang, vous pouvez utiliser l'option defer pour différer les appels de fonction.

Bien qu'il soit utilisé dans des applications telles que le nettoyage des ressources et la gestion des erreurs, il peut être utile de comprendre comment utiliser defer à l'intérieur d'une boucle for. Voyons ce qui se passe lorsque nous utilisons defer à l'intérieur de la boucle for pour différer les appels à la fonction Println() fonction.

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		defer fmt.Println(i)
	}
}

💬 Lorsqu'un appel de fonction est différé, l'appel de fonction est poussé sur la pile et est exécuté en Ordre LIFO. Cette exécution ne se produit que après la fonction qui entoure la déclaration de report revient.

Donc fmt.Println(5) est exécuté en premier et fmt.Println(1) est exécuté en dernier :

//Output
For loop:
5
4
3
2
1

Conclusion

Voici un résumé de ce que vous avez appris dans ce tutoriel :

Dans Golang, vous pouvez créer des boucles for avec la syntaxe : for initialization; condition; update { //loop body}.
Le flux de contrôle de la boucle for est assez simple. La variable de boucle est initialisée une fois, la condition de recherche détermine si le corps de la boucle doit être exécuté ou non, et la mise à jour fait référence à la mise à jour de la variable de boucle après chaque itération.
La portée de la variable de bouclage est limitée au corps de la boucle et n'est pas accessible en dehors de la boucle.
Bien que Golang ne fournisse que la construction de boucle for, vous pouvez émuler les comportements de boucle while et do-while en utilisant des boucles for.
Parmi les autres applications de la boucle for, citons le bouclage de tableaux et le report des appels de fonction dans le corps de la boucle for.

Ensuite, apprenez à utiliser boucles for en Python. Bon apprentissage!🎉

Bala Priya C

Auteur