For...Next, instruction (Visual Basic)

Article
08/10/2011

Répète un groupe d'instructions un nombre spécifié de fois.

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

Éléments

Élément	Description
counter	Requis dans l'instruction For. Variable numérique. Variable de contrôle de la boucle.
datatype	Obligatoire si counter n'est pas déjà déclaré. Type de données de counter.
start	Obligatoire. Expression numérique. Valeur initiale de counter.
end	Obligatoire. Expression numérique. Valeur finale de counter.
step	Facultatif. Expression numérique. Valeur d'incrémentation de counter à chaque itération de la boucle.
statements	Facultatif. Une ou plusieurs instructions entre For et Next à exécuter le nombre de fois spécifié.
Continue For	Facultatif. Transfère le contrôle à l'itération suivante de la boucle.
Exit For	Facultatif. Transfert le contrôle hors de la boucle For.
Next	Obligatoire. Termine la définition de la boucle For.

Notes

Le mot clé To est utilisé ici pour spécifier la plage pour le compteur. Il est également utilisé pour spécifier une plage de valeurs dans Select...Case, instruction (Visual Basic) et dans les déclarations de tableau. Pour plus d'informations sur les déclarations de tableau, consultez Dim, instruction (Visual Basic).

Notes

Utilisez une structure For...Next lorsque vous souhaitez répéter une série d'instructions un nombre défini de fois.

Lorsque la boucle For...Next commence, Visual Basic évalue start, end et step. Il s'agit de l'unique cas où il évalue ces valeurs. Il assigne ensuite start à counter. Avant d'exécuter le bloc d'instructions, il compare counter à end. Si 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 passe à l'instruction suivant 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 la valeur de step et retourne à l'instruction For. Il compare de nouveau counter à end et exécute à nouveau le bloc ou quitte la boucle selon le résultat. Ce processus continue jusqu'à ce que counter 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 est égal à end, la boucle continue. La comparaison qui détermine l'exécution du bloc est counter <= end si step est positif et counter >= end si step est négatif.

Changer la valeur de counter quand une boucle est en cours d'exécution rendra la lecture et le débogage de votre code plus difficiles. Changer la valeur de start, end ou step n'affecte pas les valeurs d'itération déterminées lors de la première entrée de la boucle.

Conseil

Une boucle While...End While, instruction (Visual Basic) ou Do...Loop, instruction (Visual Basic) fonctionne bien lorsque vous ne connaissez pas à l'avance le nombre de fois où les instructions doivent être exécutées dans une boucle. Toutefois, si vous devez exécuter la boucle un certain nombre de fois, il est préférable d'utiliser For...Next. Vous déterminez le nombre d'itérations lorsque vous entrez la boucle pour la première fois.

Argument d'étape

La valeur de step peut être positive ou négative. Elle détermine le traitement de la boucle comme suit :

Valeur de step	Condition d'exécution de la boucle
Positive ou zéro	counter <= end
Négatif	counter >= end

Si aucune valeur n'est spécifiée, l'argument step prend par défaut la valeur 1.

Argument de compteur

Si la variable counter n'a pas été déclarée à l'extérieur de cette boucle, vous devez la déclarer dans l'instruction For. Dans ce cas, la portée de counter est le corps de la boucle. Cependant, vous ne pouvez pas déclarer counter à la fois à l'extérieur et à l'intérieur de la boucle.

Vous pouvez éventuellement définir counter dans l'instruction Next. Cela améliore la lisibilité de votre programme, surtout si vous avez imbriqué des boucles For. Vous devez spécifier la même variable que celle qui apparaît dans l'instruction For correspondante.

Le type de données de counter détermine le type de l'itération et doit être l'un des suivants :

Byte, SByte, UShort, Short, UInteger, Integer, ULong, Long, Decimal, Single ou Double.
Énumération que vous déclarez à l'aide d'une Enum, instruction (Visual Basic).
Object.
Type T qui a les opérateurs suivants, où B est un type qui peut ê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

Les expressions start, end et step peuvent avoir pour valeur tout type de données qui s'étend au type de counter. Si vous utilisez un type défini par l'utilisateur pour counter, cela signifie que vous pouvez être amené à définir l'opérateur de conversion CType pour convertir les types de start, end ou step vers le type de counter.

Imbrication de boucles

Vous pouvez imbriquer les boucles For en plaçant une boucle à l'intérieur d'une autre. Toutefois, chaque boucle doit posséder une variable counter unique.

Vous pouvez également imbriquer divers types de structures de contrôle l'un dans l'autre. Pour plus d'informations, consultez Structures de contrôle imbriquées (Visual Basic).

Si une instruction Next d'un niveau d'imbrication externe est rencontrée avant le Next d'un niveau interne, le compilateur signale une erreur. Toutefois, le compilateur peut détecter cette erreur de chevauchement uniquement si vous spécifiez counter dans chaque instruction Next.

Exit For

L'Exit, instruction (Visual Basic) quitte immédiatement la boucle For...Next et transfère le contrôle à l'instruction suivant l'instruction Next.

Vous pouvez placer n'importe quel nombre d'instructions Exit For dans une boucle For...Next. Utilisée dans des boucles For…Next imbriquées, l'instruction Exit For quitte la boucle la plus profonde et transfère le contrôle au niveau d'imbrication supérieur suivant.

Exit For est souvent utilisé après l'évaluation d'une condition, par exemple dans une structure If...Then...Else. Vous pouvez utiliser Exit For pour les conditions suivantes :

La poursuite de l'itération est inutile ou impossible. Cela peut être causé par une valeur erronée ou une demande d'arrêt.
Une exception est interceptée dans Try...Catch...Finally. Vous pouvez utiliser Exit For à la fin du bloc Finally.
Il existe une boucle sans fin, c'est-à-dire une boucle qui pourrait s'exécuter de nombreuses fois, voire indéfiniment. Si vous détectez une telle condition, vous pouvez utiliser Exit For pour abandonner la boucle. Pour plus d'informations, consultez Do...Loop, instruction (Visual Basic).

L'instruction Continue For transfère immédiatement le contrôle vers l'itération suivante de la boucle. Pour plus d'informations, consultez Continue, instruction (Visual Basic).

Exemple

L'exemple ci-dessous illustre l'utilisation de l'instruction For…Next. Une variable de compteur de boucle est incrémentée avec chaque itération de la boucle. L'argument step n'est pas spécifié, il prend donc par défaut la valeur 1.

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

Dans l'exemple suivant, les arguments counter et step sont des nombres à virgule flottante Double.

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

L'exemple suivant illustre des structures For...Next imbriquées avec différentes valeurs d'étape. 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 de boucle 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

L'exemple suivant supprime tous les éléments d'une liste générique. Au lieu d'une For Each...Next, instruction (Visual Basic), une instruction For...Next qui itère en ordre décroissant est utilisée. En effet, avec la méthode removeAt, les éléments après l'élément supprimé ont une valeur d'index moins élevée.

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

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 And 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

L'exemple suivant itère une énumération déclarée à l'aide d'une Enum, instruction (Visual Basic).

Public Enum Mammals
    Buffalo
    Gazelle
    Mongoose
    Rhinocerous
    Whale
End Enum


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

Dans l'exemple suivant, les paramètres d'instruction utilisent une classe ayant des surcharges d'opérateurs 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

Historique des modifications

Date

Historique

Motif

Décembre 2010

Réorganisation de la section Remarques et ajout d'exemples.

Améliorations apportées aux informations.

Partager via

For...Next, instruction (Visual Basic)

Éléments

Notes

Argument d'étape

Argument de compteur

Imbrication de boucles

Exit For

Exemple

Voir aussi

Tâches

Référence

Concepts

Historique des modifications

Ressources supplémentaires