Partager via

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

Partie Descriptif
counter Obligatoire dans l’instruction For. Variable numérique. Variable de contrôle pour la boucle. Pour plus d’informations, consultez Contre-argument plus loin dans cette rubrique.
datatype Optionnel. Type de données de counter. Pour plus d’informations, consultez Contre-argument plus loin dans cette rubrique.
start Obligatoire. Expression numérique. Valeur initiale de counter.
end Obligatoire. Expression numérique. Valeur finale de counter.
step Optionnel. Expression numérique. Quantité par laquelle counter est incrémentée chaque fois par le biais de la boucle.
statements Optionnel. Une ou plusieurs instructions entre For et Next qui exécutent le nombre de fois spécifié.
Continue For Optionnel. Transfère le contrôle à l’itération de boucle suivante.
Exit For Optionnel. Transfère le contrôle hors de la For boucle.
Next Obligatoire. Termine la définition de la For boucle.

Remarque

Le To mot clé est utilisé dans cette instruction pour spécifier la plage du compteur. Vous pouvez également utiliser ce mot clé dans l’instruction Select…Case et dans les déclarations de tableau. Pour plus d’informations sur les déclarations de tableau, consultez Instruction Dim.

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

Conseil / Astuce

Un instruction While...End While ou instruction Do...Loop fonctionne bien lorsque vous ne savez pas à l'avance combien de fois les instructions doivent être exécutées dans la boucle. Toutefois, lorsque vous prévoyez d’exécuter la boucle un nombre spécifique de fois, une Forboucle ...Next est un meilleur choix. Vous déterminez le nombre d'itérations lorsque vous entrez dans la boucle pour la première fois.

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 :

Valeur de l’étape La boucle s’exécute si
Positif ou zéro counter <= end
Négatif counter >= end

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.

Est-ce que datatype est présent ? Est-ce que counter est déjà défini ? Résultat (indique si une nouvelle variable locale counter est couverte par l'ensemble de la boucle For...Next)
Non Oui Non, car counter est déjà défini. Si l’étendue de counter n’est pas locale à la procédure, un avertissement de compilation se produit.
Non Non Oui. Le type de données est déduit des expressions start, end, et step. Pour plus d’informations sur l’inférence de type, consultez l’instruction Option Infer et l’inférence de type local.
Oui Oui Oui, mais uniquement si la variable existante counter est définie en dehors de la procédure. Cette variable reste distincte. Si l’étendue de la variable existante counter est locale dans la procédure, une erreur au moment de la compilation se produit.
Oui Non Oui.

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

  • Last updated on