Faire... Instruction de boucle (Visual Basic)

2025-07-31

Répète un bloc d’instructions pendant qu’une Boolean condition est True ou jusqu’à ce que la condition devienne True.

Syntaxe

Do [ { While | Until } condition ]
    [ statements ]
    [ Continue Do ]
    [ statements ]
    [ Exit Do ]
    [ statements ]
Loop
' -or-
Do
    [ statements ]
    [ Continue Do ]
    [ statements ]
    [ Exit Do ]
    [ statements ]
Loop [ { While | Until } condition ]

Pièces

Terme	Définition
`Do`	Obligatoire. Démarre la définition de la `Do` boucle.
`While`	Ne peut pas être donné s’il `Until` est utilisé. Répétez la boucle jusqu’à ce qu’elle `condition` soit `False`.
`Until`	Ne peut pas être donné s’il `While` est utilisé. Répétez la boucle jusqu’à ce qu’elle `condition` soit `True`.
`condition`	Optionnel. `Boolean` expression. Si `condition` c’est `Nothing`le cas, Visual Basic le traite comme `False`.
`statements`	Optionnel. Une ou plusieurs instructions qui sont répétées pendant, ou jusqu’à ce que, `condition` soit `True`.
`Continue Do`	Optionnel. Transfère le contrôle à l’itération suivante de la `Do` boucle.
`Exit Do`	Optionnel. Transfère le contrôle hors de la `Do` boucle.
`Loop`	Obligatoire. Termine la définition de la `Do` boucle.

Remarques

Utilisez une Do...Loop structure lorsque vous souhaitez répéter un ensemble d’instructions un nombre indéfini de fois, jusqu’à ce qu’une condition soit satisfaite. Si vous souhaitez répéter les instructions un nombre défini de fois, le For... L’instruction suivante est généralement un meilleur choix.

Vous pouvez utiliser ou WhileUntil spécifier condition, mais pas les deux. Si vous ne donnez ni l’un ni l’autre, la boucle continue jusqu’à ce qu’un Exit contrôle de transfert soit hors de la boucle.

Vous ne pouvez tester condition qu’une seule fois, au début ou à la fin de la boucle. Si vous testez condition au début de la boucle (dans l’instruction Do ), la boucle risque de ne pas s’exécuter une seule fois. Si vous testez à la fin de la boucle (dans l’instruction Loop ), la boucle s’exécute toujours au moins une fois.

La condition résulte généralement d’une comparaison de deux valeurs, mais il peut s’agir d’une expression qui prend la valeur d’un type de données booléen (True ou False). Cela inclut des valeurs d’autres types de données, tels que des types numériques, qui ont été convertis en Boolean.

Vous pouvez imbriquer des boucles Do en plaçant une boucle à l'intérieur d'une autre. Vous pouvez également imbriquer différents types de structures de contrôle entre elles. Pour plus d’informations, consultez Structures de contrôle imbriquées.

Remarque

La Do...Loop structure vous donne plus de flexibilité que le While... End While, car elle vous permet de décider s’il faut mettre fin à la boucle lorsqu’elle condition cesse d’être True ou quand elle devient True. Il vous permet également de tester condition au début ou à la fin de la boucle.

Exit Do

L’instruction Exit Do peut fournir un autre moyen de quitter un Do…Loop. Exit Do transfère immédiatement le contrôle à l’instruction qui suit l’instruction Loop .

Exit Do est souvent utilisé après l’évaluation d’une condition, par exemple dans une If...Then...Else structure. Vous pouvez quitter une boucle si vous détectez une condition qui rend inutile ou impossible de continuer l’itération, telle qu’une valeur erronée ou une demande d’arrêt. L’une des Exit Do utilisations consiste à tester une condition qui peut entraîner une boucle infinie, qui est une boucle qui peut exécuter un grand nombre de fois ou même infini. Vous pouvez utiliser Exit Do pour échapper à la boucle.

Vous pouvez inclure n’importe quel nombre d’instructions n’importe Exit Do où dans un Do…Loop.

Lorsqu’elles sont utilisées dans des boucles imbriquées Do , Exit Do transfère le contrôle hors de la boucle la plus interne et dans le niveau supérieur suivant d’imbrication.

Exemple 1

Dans l’exemple suivant, les instructions de la boucle continuent à s’exécuter jusqu’à ce que la index variable soit supérieure à 10. La Until clause se trouve à la fin de la boucle.

Dim index As Integer = 0
Do
    Debug.Write(index.ToString & " ")
    index += 1
Loop Until index > 10

Debug.WriteLine("")
' Output: 0 1 2 3 4 5 6 7 8 9 10

Exemple 2

L’exemple suivant utilise une While clause au lieu d’une Until clause et condition est testé au début de la boucle au lieu de la fin.

Dim index As Integer = 0
Do While index <= 10
    Debug.Write(index.ToString & " ")
    index += 1
Loop

Debug.WriteLine("")
' Output: 0 1 2 3 4 5 6 7 8 9 10

Exemple 3

Dans l’exemple suivant, condition arrête la boucle lorsque la index variable est supérieure à 100. Toutefois, l’instruction If dans la boucle entraîne l’arrêt Exit Do de la boucle lorsque la variable d’index est supérieure à 10.

Dim index As Integer = 0
Do While index <= 100
    If index > 10 Then
        Exit Do
    End If

    Debug.Write(index.ToString & " ")
    index += 1
Loop

Debug.WriteLine("")
' Output: 0 1 2 3 4 5 6 7 8 9 10

Exemple 4

L’exemple suivant lit toutes les lignes d’un fichier texte. La OpenText méthode ouvre le fichier et retourne un StreamReader qui lit les caractères. Dans la Do...Loop condition, la Peek méthode de la StreamReader méthode détermine s’il existe des caractères supplémentaires.

Private Sub ShowText(ByVal textFilePath As String)
    If System.IO.File.Exists(textFilePath) = False Then
        Debug.WriteLine("File Not Found: " & textFilePath)
    Else
        Dim sr As System.IO.StreamReader = System.IO.File.OpenText(textFilePath)

        Do While sr.Peek() >= 0
            Debug.WriteLine(sr.ReadLine())
        Loop

        sr.Close()
    End If
End Sub