Instructions de contrôle de flux dans Go

Les instructions de contrôle de flux du langage Go sont la base de sa programmation. Comme d'autres langages, elles contrôlent le flux d'exécution du programme et mettent en œuvre la prise de décision, le bouclage et la gestion des ressources. Cet article examine en profondeur les instructions de contrôle de flux de Go, notamment for, if, switch et defer, et explique comment les utiliser efficacement dans les programmes Go.

Cet article fait partie de la série de didacticiels sur le langage Go, conçu pour aider les développeurs à comprendre plus en profondeur le langage Go. Que vous soyez débutant ou développeur expérimenté, ce guide vous donnera les connaissances dont vous avez besoin pour écrire du code Go plus efficace et plus lisible.

Après avoir lu cet article, vous maîtriserez :

• Différents types d'instructions de contrôle de flux en langage Go.
• Comment utiliser ces déclarations dans des situations réelles.
• Bonnes pratiques et pièges courants.

Commençons !

Concept de base

1. forBoucle

forLa boucle est la seule structure de boucle du langage Go, mais elle est très flexible et peut être utilisée dans une variété de scénarios :

BasiqueforBoucle

<code class="language-go">for i := 0; i < 10; i++ {
    fmt.Println(i)
}</code>

Il s'agit d'une boucle « for » traditionnelle, initialisant les variables, définissant les conditions et incrémentant les variables.

forExécution continue de la boucle (similaire à la while boucle)

Go n'a pas le mot-clé `while`, mais vous pouvez utiliser une boucle `for` pour obtenir le même effet :

<code class="language-go">sum := 1
for sum < 100 {
    sum += sum
}</code>

Cette boucle continue de s'exécuter jusqu'à ce que la condition « somme < 100 » ne soit plus vraie. < 100`不成立。

Boucle infinie

Si la condition est omise, la boucle `for` s'exécutera à l'infini :

<code class="language-go">for {
    fmt.Println("无限循环")
}</code>

Ceci est utile pour les tâches qui doivent s'exécuter en continu (comme les serveurs).

2. ifDéclaration

L'instruction

`if` est utilisée pour l'exécution conditionnelle.

Déclarations de baseif

<code class="language-go">if x > 10 {
    fmt.Println("x大于10")
}</code>

if déclaration avec courte déclaration

Une courte instruction peut être exécutée avant la condition :

<code class="language-go">if x := 5; x < 10 {
    fmt.Println("x小于10")
}</code>

if et else

Vous pouvez également utiliser `else` et `else if` :

<code class="language-go">if x > 10 {
    fmt.Println("x大于10")
} else if x == 10 {
    fmt.Println("x等于10")
} else {
    fmt.Println("x小于10")
}</code>

3. switchDéclaration

L'instruction `switch` est un moyen puissant de gérer plusieurs conditions.

Déclarations de baseswitch

<code class="language-go">switch os := runtime.GOOS; os {
case "darwin":
    fmt.Println("OS X")
case "linux":
    fmt.Println("Linux")
default:
    fmt.Printf("%s.\n", os)
}</code>

switchOrdre d'exécution des déclarations

Go évalue les cas de l'instruction `switch` de haut en bas, en s'arrêtant une fois la correspondance réussie.

InconditionnelswitchDéclaration

L'instruction inconditionnelle `switch` est équivalente à `switch true` :

<code class="language-go">t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("上午")
case t.Hour() < 18:
    fmt.Println("下午")
default:
    fmt.Println("晚上")
}</code>

4. deferDéclaration

L'instruction `defer` diffère l'exécution d'une fonction jusqu'au retour de la fonction environnante.

Déclarations de basedefer

<code class="language-go">func main() {
    defer fmt.Println("world")
    fmt.Println("hello")
}</code>

Sortie :

<code>hello
world</code>

EmpilésdeferDéclarations

Les fonctions de retard sont exécutées dans l'ordre du dernier entré, premier sorti (LIFO) :

<code class="language-go">func main() {
    defer fmt.Println("first")
    defer fmt.Println("second")
    defer fmt.Println("third")
}</code>

Sortie :

<code>third
second
first</code>

Exemple pratique

Regardons un exemple pratique démontrant l'utilisation de ces instructions de contrôle de flux. Nous allons créer un programme simple qui traite une liste de tâches et imprime son statut.

<code class="language-go">for i := 0; i < 10; i++ {
    fmt.Println(i)
}</code>

Explication détaillée des étapes

1. **Structure des tâches** : Nous définissons une structure `Tâche` contenant les champs `Nom` et `Complete`.
2. **Liste des tâches** : Nous créons une tranche d'objets `Tâche`.
3. **boucle for** : nous utilisons une boucle `for` pour parcourir les tâches. Pour chaque tâche, nous utilisons une instruction « if » pour vérifier si elle est terminée.
4. **Instruction switch** : Nous utilisons l'instruction `switch` pour vérifier si aujourd'hui est un week-end ou un jour ouvrable.
5. **instruction defer** : Nous utilisons `defer` pour imprimer un message une fois que toutes les tâches sont traitées.

Bonnes pratiques

1. **Utilisez judicieusement les boucles for** : Puisque Go n'a que des boucles `for`, assurez-vous de les utiliser correctement. Évitez les boucles infinies sauf si nécessaire.
2. **Gardez les instructions if simples** : utilisez des instructions courtes dans les conditions « if » pour rendre le code concis et facile à lire.
3. **Utilisez switch pour gérer plusieurs conditions** : Lorsque vous traitez plusieurs conditions, une instruction « switch » est plus lisible que plusieurs instructions « if-else ».
4. **Utilisez defer pour le nettoyage** : `defer` est idéal pour le nettoyage des ressources, comme la fermeture de fichiers ou la libération de verrous.
5. **Évitez l'imbrication profonde** : les instructions `if` ou `for` profondément imbriquées peuvent rendre le code difficile à lire. Pensez à refactoriser en fonction.

Conclusion

Les instructions de contrôle de flux sont des outils essentiels dans le langage Go. Elles vous permettent de contrôler le flux d'exécution de votre programme. En maîtrisant « for », « if », « switch » et « defer », vous pouvez écrire du code Go plus efficace, lisible et maintenable.

Je vous encourage à essayer les exemples fournis dans cet article et à expérimenter les concepts par vous-même.

Appel à l'action

Cet article fait partie de la série de didacticiels sur le langage Go, conçue pour vous aider à devenir un développeur Go plus compétent. Si vous avez trouvé cet article utile, assurez-vous de consulter les didacticiels précédents et à venir de cette série. Découvrez-le sur mon blog ou Dev.to.

Bonne programmation ! ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!