for (référence C#)

 

Pour obtenir la dernière documentation sur Visual Studio 2017 RC, consultez Documentation Visual Studio 2017 RC.

À l'aide d'une boucle d' for , vous pouvez exécuter une instruction ou un bloc d'instructions à plusieurs reprises jusqu'à ce qu'une expression spécifiée prend la false. Ce genre de boucle est utile pour itérer au sein de les tableaux et d'autres applications dans lesquelles vous connaissez à l'avance la fréquence à laquelle vous souhaitez que la boucle pour itérer.

Dans l'exemple suivant, la valeur d' i est écrite dans la console et incrémenté par 1 pendant chaque itération de la boucle.

    
    class ForLoopTest 
    {
        static void Main() 
        {
            for (int i = 1; i <= 5; i++)
            {
                Console.WriteLine(i);
            }
        }
    }
    /*
    Output:
    1
    2
    3
    4
    5
    */

l'instruction d' for dans l'exemple précédent exécute les actions suivantes.

  1. D'abord, la valeur initiale d' i variable est générée. Cette étape se produit uniquement une fois, indépendamment du nombre de fois la boucle se répète. Vous pouvez considérer cette initialisation en tant qu'événement en dehors de le processus de boucle.

  2. Pour évaluer la condition (i <= 5), la valeur d' i est comparée à 5.

    • Si i est inférieure ou égale à 5, la condition a la true, et les actions suivantes se produisent.

      1. L'instruction d' Console.WriteLine dans le corps de la boucle affiche la valeur d' i.

      2. La valeur d' i est incrémentée par 1.

      3. La boucle retourne au début de l'étape 2 pour évaluer la condition de nouveau.

    • Si i est supérieur à 5, la condition a la false, et vous quittez la boucle.

Notez que, si la valeur initiale d' i est supérieure à 5, le corps de la boucle ne s'exécute pas même une fois.

Chaque instruction d' for définit l'initialiseur, la condition, les sections et itérateur. Ces sections déterminent généralement le nombre de fois la boucle itère.

for (initializer; condition; iterator)  
    body  

Les sections répondent aux objectifs suivants.

  • La section d'initialiseur définit les conditions initiales. Les instructions de cette section s'exécutent qu'une seule fois, avant d'écrire la boucle. La section peut contenir un des deux options suivantes.

    • La déclaration et l'initialisation d'une variable de boucle locale, comme premier exemple montreint i = 1(). La variable est locale à la boucle et ne peut pas accessible en dehors de la boucle.

    • Expressons zéro ou plus de l'instruction de la liste suivante, séparés par des virgules.

      • Instruction d'assignation

      • appel d'une méthode

      • suffixez préfixe ou l'expression d'index, telle qu' ++i ou i++

      • suffixez préfixe ou l'expression de décrément , telle qu' --i ou i--

      • création d'un objet à l'aide de nouveau

      • expression d'attendez

  • La section de condition contient une expression booléenne qui est évaluée pour déterminer si la boucle doit quitter ou exécuter de nouveau.

  • La section des itérateurs définit ce qui se produit après chaque itération du corps de la boucle. La section des itérateurs contient zéro ou plusieurs expressions suivantes de l'instruction, séparés par des virgules :

    • Instruction d'assignation

    • appel d'une méthode

    • suffixez préfixe ou l'expression d'index, telle qu' ++i ou i++

    • suffixez préfixe ou l'expression de décrément , telle qu' --i ou i--

    • création d'un objet à l'aide de nouveau

    • expression d'attendez

  • Le corps de la boucle se compose d'une instruction, une instruction vide, ou un bloc d'instructions, que vous créez en plaçant zéro ou plusieurs instructions accolades.

    Vous pouvez de quitter une boucle d' for à l'aide de le mot clé de break , ou vous pouvez passer à l'itération suivante à l'aide de le mot clé de continuez . Vous pouvez également quitter une boucle à l'aide de goto, de retour, ou de l'instruction de throw .

Le premier exemple de cette rubrique indique le type le plus courant de boucle d' for , qui effectue les choix suivants pour les sections.

  • L'initialiseur déclare et initialise une variable de boucle locale, i, qui met à jour un nombre d'itérations de la boucle.

  • Les contrôles de spécification la valeur de la variable de boucle sur une valeur finale., 5.

  • La section des itérateurs utilise une instruction de post-incrémentation, i++, pour compter chaque itération de la boucle.

L'exemple suivant montre plusieurs choix moins courants : l'assignation d'une valeur à une variable de boucle externe dans la section d'initialiseur, en appelant la méthode d' Console.WriteLine dans l'initialiseur les sections et des itérateurs, et modifier les valeurs de deux variables dans la section des itérateurs.

       static void Main()
        {
            int i;
            int j = 10;
            for (i = 0, Console.WriteLine("Start: {0}",i); i < j; i++, j--, Console.WriteLine("i={0}, j={1}", i, j))
            {
                // Body of the loop.
            }
        }
        // Output:
        // Start: 0
        // i=1, j=9
        // i=2, j=8
        // i=3, j=7
        // i=4, j=6
        // i=5, j=5

Toutes les expressions qui définissent une instruction d' for sont facultatives. Par exemple, l'instruction suivante crée une boucle infinie.

            for (; ; )
            {
                // ...
            }

Pour plus d'informations, voir la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Référence C#
Guide de programmation C#
Mots clés C#
foreach, in
for, instruction (C++)
Instructions d'itération

Afficher: