Apprenez tout sur Golang pour les boucles en codant plusieurs exemples utiles.
Récemment, les 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 envisager d’apprendre Golang est une excellente option !
Si vous êtes un débutant qui apprend les bases d’un langage de programmation, les constructions de boucles sont l’un des premiers concepts que vous devez comprendre.
Golang ne fournit que la construction de la boucle for. Et nous en apprendrons davantage sur les boucles for et sur la façon d’émuler d’autres boucles à l’aide de la boucle for.
Commençons!
Table des matières
Syntaxe de la boucle Golang For
Dans Golang, vous pouvez créer une boucle for en utilisant la syntaxe suivante :
for initialization; condition; update {
// do something
}Ici,
- initialisation désigne 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 vraie, les instructions du corps de la boucle sont exécutées. Et lorsque la condition devient fausse, le contrôle sort de la boucle.
- update indique la mise à jour de la variable en boucle, généralement un incrément ou un décrément.
💡 Remarquez à quel point cela ressemble à la boucle C for uniquement sans les parenthèses.
Voici le flux de contrôle dans Golang pour les boucles :
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 boucle Golang For
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, définissons la condition sur i <= 5 et incrémentons la variable de bouclage de un après chaque itération. Et voici la sortie :
//Output For loop: 1 2 3 4 5
Écrivons une autre boucle for. Cette boucle commence à partir de 5 et compte à rebours jusqu’à 1 ; il 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 attendu :
//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 boucle for et n’est pas accessible en dehors de la boucle.
Pour vérifier cela, 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 une erreur indiquant que i est un indéfini (et sa portée est restreinte à la boucle for) :
// Output ./prog.go:11:14: undefined: i
Boucle infinie pour Golang
Pouvons-nous avoir des boucles for infinies en Go ? Oui, nous le pouvons bien sûr !
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 vraie.
- Lorsque la condition devient fausse, le contrôle sort de la boucle.
- Donc, 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. Donc, si vous pouvez exécuter 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 sur 5. Et la condition de bouclage est num >= 5. Ainsi, la boucle s’exécute tant que num est supérieur ou égal à zéro.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}Étant donné que la valeur de num ne change jamais, la condition est toujours évaluée comme vraie et la boucle s’exécute indéfiniment !
//Output 5 5 5 5 5 5 //and it goes on forever!
Tout Golang n’a que la construction de boucle for, nous pouvons essayer d’émuler les boucles while et do-while en utilisant des boucles for. Alors apprenons à le faire !
Émulation 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 boucle for infinie, nous avons écrit : 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 uniquement la condition (sous la forme suivante) pour émuler la boucle while :
//initialize looping var
for condition {
// do something
// update looping var
}Voici la boucle while équivalente à 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
Émulation 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 lors de l’entrée dans la boucle. La boucle do-while, quant à elle, vérifie la condition à la sortie de la boucle.
Ainsi, dans une boucle while, si la condition est évaluée à false, le corps de la boucle ne s’exécute jamais. Cependant, dans une boucle do-while, le corps de la boucle s’exécute même si la condition prend la valeur false.
En utilisant ces informations, nous pouvons émuler le comportement d’une boucle do-while :
- Ecrire une boucle for infinie
- Utilisez une instruction conditionnelle if avec la condition correcte pour sortir de la boucle
Supposons que vous souhaitiez écrire une boucle do-while où la condition d’exécution du corps de la boucle est 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 la sortie de la boucle si num >= 0 sont des conditions équivalentes.
Bien que la condition num > 0 soit initialement fausse (num vaut 5), le corps de la boucle s’exécute une fois, émulant une boucle do-while.
//Output Emulating do-while loop loop runs...
Boucler dans des tableaux à l’aide de la boucle For
Lorsque vous parcourez des tableaux dans Golang à l’aide d’une boucle for et d’une plage, vous pouvez accéder à la fois aux indices et aux éléments. Cela fonctionne de la même manière que la fonction enumerate en Python.
Ici, nous créons numArray, un tableau d’entiers. Et bouclez-le à 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 de 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 du report dans Golang For Loop
Dans Golang, vous pouvez utiliser le mot-clé 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 dans une boucle for. Voyons ce qui se passe lorsque nous utilisons defer dans la boucle for pour différer les appels à la fonction Println().
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é dans l’ordre LIFO. Cette exécution ne se produit qu’après le retour de la fonction qui entoure l’instruction de report.
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 didacticiel :
- Dans Golang, vous pouvez créer des boucles for avec la syntaxe : for initialization ; condition; mettre à jour { //corps de la boucle}.
- Le flux de contrôle de la boucle for est assez simple. La variable de bouclage est initialisée une fois, la condition de recherche détermine s’il faut ou non exécuter le corps de la boucle, et la mise à jour fait référence à la mise à jour de la variable de bouclage 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 à l’aide de boucles for.
- Quelques autres applications de la boucle for incluent la boucle dans des tableaux et le report des appels de fonction à l’intérieur du corps de la boucle for.
Ensuite, apprenez à utiliser les boucles for en Python. Bon apprentissage !🎉