Share via

For...Next, instruction (Visual Basic)

  • Article

Mise à jour : novembre 2007

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

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

Éléments

  • 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é.

  • Exit For
    Facultatif. Transfert le contrôle hors de la boucle For.

  • Next
    Obligatoire. Termine la définition de la boucle For.

Notes

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

Une boucle While...End While, instruction (Visual Basic) ou Do...Loop, instruction (Visual Basic) fonctionne correctement 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.

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égative

counter >= end

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

Règles

  • Types de données. Le type de données de counter est généralement Integer, mais il peut correspondre à tout type prenant en charge les opérateurs suivants : supérieur ou égal à (>=), inférieur ou égal à (<=), addition (+) et soustraction (-). Il peut même être un type défini par l'utilisateur à condition qu'il prenne en charge tous ces opérateurs.

    Les expressions start, end et step ont généralement pour valeur le type Integer, mais 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.

  • Déclaration. 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.

  • Nombre d'itérations. Visual Basic évalue les valeurs d'itération start, end et step une seule fois avant que la boucle ne commence. Si votre bloc d'instructions modifie end ou step, ces modifications n'affectent pas l'itération de la boucle.

  • 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. La construction suivante est valide :

    For i As Integer = 1 To 10
    For j As Integer = 1 To 10
        For k As Integer = 1 To 10
            ' Insert statements to operate with current values of i, j, and k.
        Next k
    Next j
Next i

    Vous pouvez également imbriquer différents types de structures de contrôle les uns dans les autres. Pour plus d'informations, consultez Structures de contrôle imbriquées.

    Remarque :

    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.

  • Identification de la variable de contrôle. 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.

  • Transfert hors de la boucle. L'instruction Exit, instruction (Visual Basic) passe immédiatement le contrôle à l'instruction qui suit l'instruction Next. Vous pouvez éventuellement quitter une boucle si vous décelez une condition qui la rend inutile ou impossible pour poursuivre l'itération, telle qu'une valeur erronée ou une demande d'arrêt. Si vous décelez une exception dans un Try...Catch...Finally, vous pouvez utiliser Exit For à la fin du bloc Finally.

    Vous pouvez placer un nombre indéterminé d'instructions Exit For n'importe où dans la boucle For. Exit For est souvent utilisé après évaluation d'une certaine condition, par exemple dans une structure If...Then...Else.

  • Boucles infinies. Vous pouvez utiliser Exit For pour tester une condition qui engendrerait une boucle infinie, 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).

Comportement

  • Entrée dans la boucle. Lors de l'exécution de la boucle For...Next commence, Visual Basic évalue start, end et step pour la seule fois. Il assigne ensuite start à counter. Avant d'exécuter le bloc d'instructions, il compare counter à end. Si counter est supérieur à la valeur de fin, la boucle For se termine et le contrôle est passé à l'instruction suivant l'instruction Next. Sinon, le bloc d'instructions s'exécute.

  • Itérations de la boucle. 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 termine la boucle selon le résultat. Ce processus continue jusqu'à ce que counter passe end ou qu'une instruction Exit For soit rencontrée.

  • Arrêts de la boucle. 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.

  • Modification des valeurs d'itération. 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.

Exemple

L'exemple suivant illustre des structures For... Next imbriquées avec différentes valeurs d'étape.

Dim words, digit As Integer
Dim thisString As String = ""
For words = 10 To 1 Step -1
    For digit = 0 To 9
        thisString &= CStr(digit)
    Next digit
    thisString &= " "
Next words

L'exemple précédent crée une chaîne qui contient 10 occurrences des chiffres de 0 à 9, les chaînes étant séparées par un espace. La boucle externe décrémente une variable de compteur de boucle à chaque itération de la boucle.

Voir aussi

Tâches

Comment : améliorer les performances d'une boucle

Concepts

Structures de boucle

Structures de contrôle imbriquées

Référence

While...End While, instruction (Visual Basic)

Do...Loop, instruction (Visual Basic)

Exit, instruction (Visual Basic)

For Each...Next, instruction (Visual Basic)