Utilisation des instructions Break et Continue lors de l’utilisation de boucles en boucle

introduction

L'utilisation defor loops dans Go vous permet d'automatiser et de répéter des tâches de manière efficace.

Apprendre à contrôler le fonctionnement et le flux des boucles permettra une logique personnalisée dans votre programme. Vous pouvez contrôler vos boucles avec les instructionsbreak etcontinue.

Déclaration de pause

Dans Go, l'instructionbreak met fin à l'exécution de la boucle en cours. Unbreak est presque toujours associé à unconditional if statement.

Regardons un exemple qui utilise l'instructionbreak dans une bouclefor:

break.go

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            fmt.Println("Breaking out of loop")
            break // break here
        }
        fmt.Println("The value of i is", i)
    }
    fmt.Println("Exiting program")
}

Ce petit programme crée une bouclefor qui itérera alors quei est inférieur à10.

Dans la bouclefor, il y a une instructionif. L'instructionif teste la condition dei pour voir si la valeur est inférieure à5. Si la valeur dei n'est pas égale à5, la boucle continue et imprime la valeur dei. Si la valeur dei est égale à5, la boucle exécutera l'instructionbreak, affichera qu'il s'agit deBreaking out of loop et arrêtera d'exécuter la boucle. A la fin du programme, nous affichonsExiting program pour signifier que nous avons quitté la boucle.

Lorsque nous exécutons ce code, notre sortie sera la suivante:

OutputThe value of i is 0
The value of i is 1
The value of i is 2
The value of i is 3
The value of i is 4
Breaking out of loop
Exiting program

Cela montre qu'une fois que l'entieri est évalué comme équivalent à 5, la boucle se rompt, comme on dit au programme de le faire avec l'instructionbreak.

Boucles imbriquées

Il est important de se rappeler que l'instructionbreak arrêtera uniquement l'exécution de la boucle la plus interne dans laquelle elle est appelée. Si vous avez un ensemble imbriqué de boucles, vous aurez besoin d'une pause pour chaque boucle si vous le souhaitez.

nested.go

package main

import "fmt"

func main() {
    for outer := 0; outer < 5; outer++ {
        if outer == 3 {
            fmt.Println("Breaking out of outer loop")
            break // break here
        }
        fmt.Println("The value of outer is", outer)
        for inner := 0; inner < 5; inner++ {
            if inner == 2 {
                fmt.Println("Breaking out of inner loop")
                break // break here
            }
            fmt.Println("The value of inner is", inner)
        }
    }
    fmt.Println("Exiting program")
}

Dans ce programme, nous avons deux boucles. Alors que les deux boucles sont répétées 5 fois, chacune a une instruction conditionnelleif avec une instructionbreak. La boucle externe se rompra si la valeur deouter est égale à3. La boucle interne se rompra si la valeur deinner est2.

Si nous exécutons le programme, nous pouvons voir le résultat:

OutputThe value of outer is 0
The value of inner is 0
The value of inner is 1
Breaking out of inner loop
The value of outer is 1
The value of inner is 0
The value of inner is 1
Breaking out of inner loop
The value of outer is 2
The value of inner is 0
The value of inner is 1
Breaking out of inner loop
Breaking out of outer loop
Exiting program

Notez que chaque fois que la boucle interne se rompt, la boucle externe ne se rompt pas. C'est parce quebreak ne cassera que la boucle la plus interne à partir de laquelle il est appelé.

Nous avons vu comment utiliserbreak arrêterait l'exécution d'une boucle. Ensuite, voyons comment poursuivre l’itération d’une boucle.

Déclaration continue

L'instructioncontinue est utilisée lorsque vous souhaitez ignorer la partie restante de la boucle, revenir en haut de la boucle et continuer une nouvelle itération.

Comme pour l'instructionbreak, l'instructioncontinue est couramment utilisée avec une instruction conditionnelleif.

En utilisant le même programme de bouclefor que dans la sectionBreak Statement précédente, nous utiliserons une instructioncontinue plutôt qu'une instructionbreak:

continue.go

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            fmt.Println("Continuing loop")
            continue // break here
        }
        fmt.Println("The value of i is", i)
    }
    fmt.Println("Exiting program")
}

La différence dans l'utilisation de l'instructioncontinue plutôt que d'une instructionbreak est que notre code continuera malgré l'interruption lorsque la variablei est évaluée comme équivalente à5. Regardons notre sortie:

OutputThe value of i is 0
The value of i is 1
The value of i is 2
The value of i is 3
The value of i is 4
Continuing loop
The value of i is 6
The value of i is 7
The value of i is 8
The value of i is 9
Exiting program

Ici, nous voyons que la ligneThe value of i is 5 n'apparaît jamais dans la sortie, mais la boucle continue après ce point pour imprimer les lignes pour les nombres 6-10 avant de quitter la boucle.

Vous pouvez utiliser l'instructioncontinue pour éviter le code conditionnel profondément imbriqué, ou pour optimiser une boucle en éliminant les cas fréquents que vous souhaitez rejeter.

L'instructioncontinue oblige un programme à ignorer certains facteurs qui apparaissent dans une boucle, mais continue ensuite à travers le reste de la boucle.

Conclusion

Les instructionsbreak etcontinue dans Go vous permettront d'utiliser plus efficacement les bouclesfor dans votre code.

TOC