For...Next, instruction (Visual Basic)

Article
06/21/2023

Répète un groupe d’instructions un nombre de fois spécifique.

Syntaxe

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

Éléments

Élément	Description
`counter`	Obligatoire dans l’instruction `For`. Variable numérique. Variable de contrôle pour la boucle. Pour plus d’informations, consultez Argument compteur plus loin dans cette rubrique.
`datatype`	Optionnel. Type de données de `counter`. Pour plus d’informations, consultez Argument compteur 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.

Notes

Le To mot clé est utilisé dans cette instruction pour spécifier la plage du compteur. Vous pouvez également utiliser ce mot clé dans Sélection...Instruction de boîte et dans les instructions de tableau. Pour plus d’informations sur les déclarations de tableau, consultez Instruction Dim.

Exemples simples

Utilisez For...Next lorsque vous souhaitez répéter un ensemble d’instructions un nombre de fois défini.

Dans l’exemple suivant, la variable index commence par une valeur de 1 et est incrémentée avec chaque itération de la boucle, jusqu’à ce que la valeur de index atteigne 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 variable number commence à 2 et est réduite de 0,25 sur chaque itération de la boucle, et se termine une fois que la valeur de number atteint 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

Une instruction While...End While ou instruction Do...Loop fonctionne bien lorsque vous ne savez pas à l’avance combien de fois exécuter les instructions dans la boucle. Toutefois, lorsque vous prévoyez d’exécuter la boucle un nombre de fois spécifique, une boucleFor...Next est un meilleur choix. Vous déterminez le nombre d’itérations lorsque vous entrez d’abord la boucle.

Boucles d’imbrication

Vous pouvez imbriquer des boucles For en plaçant une boucle dans une autre. L’exemple suivant illustre les structures For...Next imbriquées qui ont des valeurs d’étape différentes. La boucle externe crée une chaîne à chaque itération de la boucle. La boucle interne décrémente une variable de compteur de boucles à 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 counter unique.

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.

Quitter vers et continuer vers

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

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

L'exemple ci-dessous 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’elle est utilisée dans un imbrication For…Next boucle, Exit For sort la boucle la plus interne et transfère le contrôle au niveau d’imbrication suivant supérieur.

Exit For est souvent utilisé après avoir évalué une condition (par exemple, dans une structure If... Then... Else). Vous souhaiterez peut-être utiliser Exit For dans 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 instruction Try... Catch... Finally intercepte une exception. Vous pouvez utiliser Exit For à la fin du bloc Finally.
Vous disposez d’une boucle infinie, qui est une boucle pouvant être exécutée un grand nombre de fois, voire infini. Si vous détectez une telle condition, vous pouvez utiliser Exit For pour échapper à la boucle. Pour plus d’informations, consultez Instructions Do... Loop.

Implémentation technique

Lorsqu’une boucle For...Next démarre, Visual Basic évalue start, endet step. Visual Basic évalue ces valeurs uniquement à cet instant, puis il affecte start à counter. Avant l’exécution du bloc d’instructions, Visual Basic compare counter à end. Si counter est déjà supérieur à la valeur end (ou plus petit si step est négatif), la boucle For prend fin et le contrôle passe à l’instruction suivant l’instruction Next. Sinon, le bloc d’instructions s’exécute.

Chaque fois que Visual Basic rencontre l’instruction Next , elle incrémente counter puisstep, et retourne à l’instruction For. Là encore, il compare counter à end, puis exécute encore une fois le bloc ou met fin à la boucle, en fonction du résultat. Ce processus se poursuit jusqu’à ce que counter dépasse end ou rencontre une instruction Exit For.

La boucle ne s’arrête pas tant que counter ne dépasse pas end. Si counter est égal à end, la boucle se poursuit. La comparaison qui détermine s’il faut exécuter le bloc est counter<= end si step est positif, et >counter= end si step est négatif.

Si vous modifiez la valeur counter de while à l’intérieur d’une boucle, votre code sera peut-être plus difficile à lire et à déboguer. La modification de la valeur de start, endou stepn’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 signalera 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 de chevauchement uniquement si vous spécifiez counter dans chaque instruction Next.

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 d’étape	La boucle s’exécute si
Positif ou zéro	`counter`<= `end`
Négatif	`counter`>= `end`

La valeur par défaut de step est 1.

Argument compteur

Le tableau suivant indique si counter définit une nouvelle variable locale qui s’applique à l’intégralité de la boucle For…Next. Cette détermination dépend du fait que datatype soit présente et que counter soit déjà défini.

`datatype` est-il présent ?	`counter` est-t-il déjà défini ?	Résultat (si `counter` définit une nouvelle variable locale qui s’applique à l’intégralité de la boucle `For...Next`)
Non	Oui	Non, car `counter` est déjà défini. Si la portée de `counter` n'est pas locale à la procédure, un avertissement à la compilation apparaît.
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, voir Option de déclaration d’inférence et Inférence de type local.
Oui	Oui	Oui, mais uniquement si la variable `counter` existante est définie en dehors de la procédure. Cette variable reste distincte. Si l’étendue de la variable `counter` existante est locale à la procédure, une erreur se produira au moment de la compilation.
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 :

Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single, ou Double.
Une énumération que vous déclarez à l’aide d’une instruction Enum.
Élément Object.
Un type T comprenant les opérateurs suivants, où B est un type pouvant être utilisé dans une expression Boolean.

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 variable counter dans l’instruction Next. Cette syntaxe améliore la lisibilité de votre programme, en particulier si vous avez des boucles Forimbriquées. Vous devez spécifier la variable qui apparaît dans l’instruction For correspondante.

Les expressions start, end et step peuvent évaluer n’importe quel type de données 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 de conversion CType pour convertir les types de start, endou step vers le type de counter.

Exemple 1

L’exemple suivant montre comment supprimer les éléments d’une liste générique. Au lieu d’une instruction For Each... Next, l’exemple montre une instruction For...Next qui procède par ordre décroissant. L'exemple utilise cette technique parce que la méthode removeAt fait en sorte que les éléments situés après l'élément supprimé ont 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 réalise 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 d’instruction utilisent une classe comprenant des surcharges d’opérateur 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

Partage via