Instruction For…Next (Visual Basic)

Répète un groupe d’instructions tant que le compteur de boucle se rapproche de sa valeur finale.

Syntaxe

For counter [ As datatype ] = start To end [ Step step ]
    [ statements ]
    [ Continue For ]
    [ statements ]
    [ Exit For ]
    [ statements ]
Next [ counter ]

Pièces

Exemples simples

Vous utilisez une Forstructure ...Next lorsque vous souhaitez répéter un ensemble d’instructions un nombre défini de fois.

Dans l’exemple suivant, la variable index commence avec une valeur de 1 et est incrémentée à chaque itération de la boucle, et se termine lorsque la valeur de index atteint 5.

For index As Integer = 1 To 5
    Debug.Write(index.ToString & " ")
Next
Debug.WriteLine("")
' Output: 1 2 3 4 5

Dans l’exemple suivant, la number variable commence à 2 et est réduite de 0,25 sur chaque itération de la boucle, se terminant une fois la valeur atteinte number à 0. L’argument Step de -.25 réduit la valeur de 0,25 à chaque itération de la boucle.

For number As Double = 2 To 0 Step -0.25
    Debug.Write(number.ToString & " ")
Next
Debug.WriteLine("")
' Output: 2 1.75 1.5 1.25 1 0.75 0.5 0.25 0 

Boucles d’imbrication

Vous pouvez imbriquer des boucles For en plaçant une boucle à l'intérieur d'une autre. L’exemple suivant illustre des structures For imbriquées Next qui ont des valeurs d’étape différentes. La boucle externe crée une chaîne pour chaque itération de la boucle. La boucle interne décrémente une variable de compteur pour chaque itération de la boucle.

For indexA = 1 To 3
    ' Create a new StringBuilder, which is used
    ' to efficiently build strings.
    Dim sb As New System.Text.StringBuilder()

    ' Append to the StringBuilder every third number
    ' from 20 to 1 descending.
    For indexB = 20 To 1 Step -3
        sb.Append(indexB.ToString)
        sb.Append(" ")
    Next indexB

    ' Display the line.
    Debug.WriteLine(sb.ToString)
Next indexA
' Output:
'  20 17 14 11 8 5 2
'  20 17 14 11 8 5 2
'  20 17 14 11 8 5 2

Lors de l’imbrication de boucles, chaque boucle doit avoir une variable unique counter .

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.

Exit For et Continue For

L’instruction Exit For quitte immédiatement le For… Next boucle et transfère le contrôle à l’instruction qui suit l’instruction Next .

L’instruction transfère immédiatement le contrôle Continue For à l’itération suivante de la boucle. Pour en savoir plus, consultez Instruction Continue.

L’exemple suivant illustre l’utilisation des instructions Continue For et Exit For.

For index As Integer = 1 To 100000
    ' If index is between 5 and 7, continue
    ' with the next iteration.
    If index >= 5 AndAlso index <= 8 Then
        Continue For
    End If

    ' Display the index.
    Debug.Write(index.ToString & " ")

    ' If index is 10, exit the loop.
    If index = 10 Then
        Exit For
    End If
Next
Debug.WriteLine("")
' Output: 1 2 3 4 9 10

Vous pouvez placer n’importe quel nombre d’instructions Exit For dans un For... Boucle Next. Lorsqu’il est utilisé dans une structure imbriquée For... Next effectue une boucle, Exit For quitte la boucle la plus interne et transfère le contrôle au niveau supérieur suivant d’imbrication.

Exit For est souvent utilisé après avoir évalué une condition (par exemple, dans un If...Then...Else structure). Vous souhaiterez peut-être utiliser Exit For pour les conditions suivantes :

• Continuer à itérer est inutile ou impossible. Une valeur erronée ou une demande d’arrêt peut créer cette condition.

• Une Try...Catch...Finally instruction intercepte une exception. Vous pouvez utiliser Exit For à la fin du Finally bloc.

• Vous disposez d'une boucle infinie, qui est une boucle qui peut s'exécuter un grand nombre de fois ou même un nombre infini de fois. Si vous détectez une telle condition, vous pouvez l’utiliser Exit For pour échapper à la boucle. Pour plus d’informations, consultez Instruction Do...Loop.

Implémentation technique

Lorsqu’une Forboucle ...Next démarre, Visual Basic évalue start, endet step. Visual Basic évalue ces valeurs uniquement pour l’instant, puis les start affecte à counter. Avant l'exécution du bloc d'instructions, Visual Basic compare counter à end. If counter est déjà supérieur à la valeur end (ou inférieur si step est négatif), la boucle For se termine et le contrôle transmet l’instruction qui suit l’instruction Next. Sinon, le bloc d’instructions s’exécute.

Chaque fois que Visual Basic rencontre l’instruction Next, il incrémente counter de step et retourne à l’instruction For. Encore une fois, counter est comparé à end, et il exécute le bloc ou quitte la boucle, selon le résultat. Le processus continue jusqu'à ce que counter dépasse end ou qu'une instruction Exit For soit rencontrée.

La boucle ne s’arrête pas tant que counter n’a pas passé end. Si counter elle est égale à end, la boucle se poursuit. Comparaison qui détermine s’il faut exécuter le bloc est counter<= end s’il step est positif etcounter> = end s’il step est négatif.

Si vous modifiez la valeur de counter lorsque vous êtes à l'intérieur d'une boucle, votre code peut être plus difficile à lire et à déboguer. La modification de la valeur start, end ou step n’affecte pas les valeurs d’itération qui ont été déterminées lors de la première entrée de la boucle.

Si vous imbriquez des boucles, le compilateur signale une erreur s’il rencontre l’instruction Next d’un niveau d’imbrication externe avant l’instruction Next d’un niveau interne. Toutefois, le compilateur peut détecter cette erreur qui se chevauche uniquement si vous spécifiez counter dans chaque Next instruction.

Argument d’étape

La valeur de step peut être positive ou négative. Ce paramètre détermine le traitement de boucles en fonction du tableau suivant :

La valeur par défaut est step 1.

Contre-argument

Le tableau suivant indique si counter définit une nouvelle variable locale ayant une portée sur l'intégralité de la boucle For…Next. Cette détermination dépend de la présence de datatype et de la définition préalable de counter.

Le type de données de counter détermine le type de l’itération, qui doit être l’un des types suivants :

• A Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single ou Double.

• Énumération que vous déclarez à l’aide d’une instruction Enum.

• Élément Object.

• T Type qui a les opérateurs suivants, où B est un type qui peut être utilisé dans une Boolean expression.

  Public Shared Operator >= (op1 As T, op2 As T) As B

  Public Shared Operator <= (op1 As T, op2 As T) As B

  Public Shared Operator - (op1 As T, op2 As T) As T

  Public Shared Operator + (op1 As T, op2 As T) As T

Vous pouvez éventuellement spécifier la counter variable dans l’instruction Next . Cette syntaxe améliore la lisibilité de votre programme, en particulier si vous avez des boucles imbriquées For . Vous devez spécifier la variable qui apparaît dans l’instruction correspondante For .

Les expressions start, end, et step peuvent évaluer n’importe quel type de donnée qui s’étend au type de counter. Si vous utilisez un type défini par l’utilisateur pour counter, vous devrez peut-être définir l’opérateur CType de conversion pour convertir les types de start, endou step vers le type de counter.

Exemple 1

L’exemple suivant supprime tous les éléments d’une liste générique. Au lieu d’un For Each... Instruction suivante, l’exemple montre une Forinstruction ...Next qui itère dans l’ordre décroissant. L’exemple utilise cette technique, car la removeAt méthode entraîne l’utilisation d’éléments après l’élément supprimé avec une valeur d’index inférieure.

Dim lst As New List(Of Integer) From {10, 20, 30, 40}

For index As Integer = lst.Count - 1 To 0 Step -1
    lst.RemoveAt(index)
Next

Debug.WriteLine(lst.Count.ToString)
' Output: 0

Exemple 2

L’exemple suivant itère dans une énumération déclarée à l’aide d’une instruction Enum.

Public Enum Mammals
    Buffalo
    Gazelle
    Mongoose
    Rhinoceros
    Whale
End Enum

Public Sub ListSomeMammals()
    For mammal As Mammals = Mammals.Gazelle To Mammals.Rhinoceros
        Debug.Write(mammal.ToString & " ")
    Next
    Debug.WriteLine("")
    ' Output: Gazelle Mongoose Rhinoceros
End Sub

Exemple 3

Dans l’exemple suivant, les paramètres de déclaration utilisent une classe qui a des surcharges pour les opérateurs +, -, >= et <=.

Private Class Distance
    Public Property Number() As Double

    Public Sub New(ByVal number As Double)
        Me.Number = number
    End Sub

    ' Define operator overloads to support For...Next statements.
    Public Shared Operator +(ByVal op1 As Distance, ByVal op2 As Distance) As Distance
        Return New Distance(op1.Number + op2.Number)
    End Operator

    Public Shared Operator -(ByVal op1 As Distance, ByVal op2 As Distance) As Distance
        Return New Distance(op1.Number - op2.Number)
    End Operator

    Public Shared Operator >=(ByVal op1 As Distance, ByVal op2 As Distance) As Boolean
        Return (op1.Number >= op2.Number)
    End Operator

    Public Shared Operator <=(ByVal op1 As Distance, ByVal op2 As Distance) As Boolean
        Return (op1.Number <= op2.Number)
    End Operator
End Class

Public Sub ListDistances()
    Dim distFrom As New Distance(10)
    Dim distTo As New Distance(25)
    Dim distStep As New Distance(4)

    For dist As Distance = distFrom To distTo Step distStep
        Debug.Write(dist.Number.ToString & " ")
    Next
    Debug.WriteLine("")

    ' Output: 10 14 18 22 
End Sub

Voir aussi

• List<T>
• Structures de boucle
• Instruction While…End While
• Instruction Do…Loop
• Structures de contrôle imbriquées
• Instruction de sortie
• Regroupements