Exercice - Créer et configurer des boucles d’itération for

14 minutes

Sur la surface, l’instruction for est une autre instruction d’itération qui vous permet d’effectuer une itération dans un bloc de code et ainsi de modifier le flux d’exécution de votre code. Toutefois, une fois que nous examinons le fonctionnement de chaque instruction, nous pouvons mieux identifier les nuances de chaque instruction d’itération et quand les utiliser.

Qu’est-ce que l’instruction `for` ?

L’instruction for itère dans un bloc de code un nombre spécifique de fois. Ce niveau de contrôle rend l’instruction for unique parmi les autres instructions d’itération. L’instruction foreach itère à travers un bloc de code une fois pour chaque élément d'une séquence de données comme un tableau ou une collection. L’instruction while itère dans un bloc de code jusqu’à ce qu’une condition soit remplie.

En outre, l’instruction for vous donne beaucoup plus de contrôle sur le processus d’itération en exposant les conditions d’itération.

Dans cet exercice, vous allez utiliser l’instruction for , apprendre à contrôler la condition préalable de l’itération, la condition d’achèvement, son modèle d’itération et bien plus encore. En outre, vous découvrirez les cas d’usage courants de l’instruction for .

Ok, nous allons maintenant préparer notre environnement de codage et commencer notre examen des exemples de code qui implémentent une for instruction.

Préparer votre environnement de programmation

Ce module comprend des activités pratiques qui vous guident tout au long du processus de création et d’exécution du code de démonstration. Nous vous encourageons à effectuer ces activités à l’aide de Visual Studio Code comme environnement de développement. L’utilisation de Visual Studio Code pour ces activités vous permet d’être plus à l’aise dans l’écriture et l’exécution de code dans un environnement de développement qui est utilisé par les professionnels du monde entier.

Ouvrez Visual Studio Code.

Vous pouvez utiliser le menu Démarrer de Windows (ou une ressource équivalente pour un autre système d’exploitation) pour ouvrir Visual Studio Code.
Dans le menu Fichier Visual Studio Code, sélectionnez Ouvrir le dossier.
Dans la boîte de dialogue Ouvrir le dossier , accédez au dossier Windows Desktop.

Si vous conservez vos projets de code dans un autre dossier, vous pouvez utiliser cet emplacement à la place. Pour cette formation, l’important est d’avoir un emplacement facile à localiser et à mémoriser.
Dans la boîte de dialogue Ouvrir le dossier , sélectionnez Sélectionner un dossier.

Si vous voyez une boîte de dialogue de sécurité vous demandant si vous approuvez les auteurs, sélectionnez Oui.
Dans le menu Terminal Visual Studio Code, sélectionnez Nouveau terminal.

Notez qu’une invite de commandes dans le panneau Terminal affiche le chemin du dossier actif. Par exemple:
```
C:\Users\someuser\Desktop>
```
Remarque

Si vous travaillez sur votre propre PC plutôt que dans un bac à sable ou un environnement hébergé et que vous avez terminé d’autres modules Microsoft Learn dans cette série C#, vous avez peut-être déjà créé un dossier de projet pour les exemples de code. Si c’est le cas, vous pouvez passer à l’étape suivante, qui est utilisée pour créer une application console dans le dossier TestProject.
À l’invite de commandes terminal, pour créer une application console dans un dossier spécifié, entrez l’invite suivante :
```
dotnet new console -o ./CsharpProjects/TestProject
```
Cette commande CLI .NET utilise un modèle de programme .NET pour créer un projet d’application console C# à l’emplacement du dossier spécifié. La commande crée les dossiers CsharpProjects et TestProject automatiquement, et utilise TestProject comme nom pour votre fichier .csproj.

Si un message s’affiche pour vous indiquer que les fichiers existent déjà, passez aux étapes suivantes. Vous allez réutiliser les fichiers projet existants.
Dans l’affichage EXPLORATEUR, développez le dossier CsharpProjects .

Vous devez voir le dossier TestProject et deux fichiers, un fichier de programme C# nommé Program.cs et un fichier projet C# nommé TestProject.csproj.
Dans le menu Fichier Visual Studio Code, sélectionnez Ouvrir le dossier.
Dans la boîte de dialogue Ouvrir un dossier , sélectionnez le dossier CsharpProjects , puis sélectionnez Sélectionner un dossier.
Dans l’affichage EXPLORATEUR, développez le dossier TestProject, puis sélectionnez Program.cs.
Supprimez les lignes de code existantes.

Vous allez utiliser ce projet de console C# pour créer, générer et exécuter des exemples de code au cours de ce module.
Fermez le panneau du Terminal.

Écrire une instruction for de base

Vérifiez que Visual Studio Code est ouvert et que Program.cs est affiché dans le panneau d’édition.

Remarque

Program.cs doit être vide. Si ce n’est pas le cas, sélectionnez toutes les lignes de code et supprimez-les.
Tapez le code suivant dans l’Éditeur Visual Studio Code.
```
for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
}
```
Ce code présente une instruction simple for qui effectue une boucle dans son bloc de code 10 fois, en imprimant la valeur actuelle de i.
Dans le menu Fichier Visual Studio Code, sélectionnez Enregistrer.

Le fichier Program.cs doit être enregistré avant de générer ou d’exécuter le code.
Dans le panneau EXPLORATEUR, pour ouvrir un terminal à l’emplacement de votre dossier TestProject, cliquez avec le bouton droit sur TestProject, puis sélectionnez Ouvrir dans le terminal intégré.

Un panneau Terminal s’ouvre. Le Terminal doit inclure une invite de commandes indiquant qu’il est ouvert à l’emplacement de votre dossier TestProject.
À l’invite de commandes terminal, pour exécuter votre code, tapez dotnet run , puis appuyez sur Entrée.

Remarque

Si vous voyez un message indiquant « Impossible de trouver un projet à exécuter », vérifiez que l’invite de commandes Terminal affiche l’emplacement attendu du dossier TestProject. Par exemple : C:\Users\someuser\Desktop\csharpprojects\TestProject>

Vous devez voir la sortie suivante.
```
0
1
2
3
4
5
6
7
8
9
```
Prenez une minute pour identifier les six parties de l’instruction for .

L’instruction for comprend les six parties suivantes :
1. Le mot clé for
2. Ensemble de parenthèses qui définit les conditions d’itération for . Les parenthèses contiennent trois parties distinctes, séparées par l’opérateur de fin d’instruction, un point-virgule.
3. La première partie définit et initialise la variable d’itérateur. Dans cet exemple : int i = 0. Cette section est appelée initialiseur.
4. La deuxième partie définit la condition d’achèvement. Dans cet exemple : i < 10. En d’autres termes, l'environnement d'exécution continuera d’itérer sur le code dans le bloc de code sous l’instruction for tant que i est inférieur à 10. Lorsqu’il i devient égal à 10, le runtime arrête l’exécution du bloc de code de l’instruction for . Les documents font référence à cette section comme condition.
5. La troisième partie définit l’action à entreprendre après chaque itération. Dans ce cas, après chaque itération, i++ incrémente la valeur de i 1. Les documents font référence à cette section en tant qu’itérateur.
6. Enfin, le bloc de code. Le bloc de code contient le code qui sera exécuté pour chaque itération. Notez que la valeur de celle-ci i est référencée à l’intérieur du bloc de code. Les documents font référence à cette section en tant que corps.
Compte tenu de nos règles pour les variables de nommage, vous pouvez vous demander s’il i s’agit d’un nom valide pour la variable qui contient l’itération actuelle. Dans ce cas, i est considéré par la plupart comme valide. D’autres choix populaires sont x et counter. Le nom j est également utilisé dans ces situations lorsque vous avez une instruction externe for qui utilise i, et devez créer une variable d’itération pour une instruction interne for .

Remarque

Les trois sections (initialiseur, condition et itérateur) sont facultatives. Toutefois, dans la pratique, les trois sections sont généralement utilisées.

Modifier les conditions d’itération

Comme nous l’avons indiqué au début, l’instruction for a deux qualités uniques parmi les instructions d’itération.

L’instruction for doit être utilisée lorsque vous connaissez le nombre de fois que vous devez itérer dans un bloc de code à l’avance.
L’instruction for vous permet de contrôler la façon dont chaque itération est gérée.

Que se passe-t-il si nous avons besoin d'itérer dans un bloc de code, mais que nous voulons compter à rebours plutôt que de compter vers le haut ?

Utilisez Visual Studio Code Editor pour mettre à jour votre code comme suit :
```
for (int i = 10; i >= 0; i--)
{
    Console.WriteLine(i);
}
```
Prenez une minute pour passer en revue votre code mis à jour.

En modifiant les trois parties de l’instruction for , nous modifions son comportement.
- Nous initialisons la variable d’itération à 10.
- Nous modifions la condition d’achèvement pour quitter l’instruction for lorsque i est inférieur à 0.
- Nous modifions le modèle de l'itérateur pour soustraire 1 de i chaque fois que nous effectuons une itération.
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

Entrez dotnet run à partir de l’invite de commandes du Terminal pour exécuter votre code.
Notez que la sortie a changé.

Lorsque vous exécutez le code, vous verrez la sortie suivante.
```
10
9
8
7
6
5
4
3
2
1
0
```

Tester le modèle de l’itérateur

Que se passe-t-il si nous voulions ignorer certaines valeurs dans la variable d’itérateur ?

Utilisez Visual Studio Code Editor pour mettre à jour votre code comme suit :
```
for (int i = 0; i < 10; i += 3)
{
    Console.WriteLine(i);
}
```
Prenez une minute pour passer en revue votre code mis à jour.

Au lieu d’incrémenter ou de décrémenter la valeur de la variable itérateur par 1, nous utilisons i += 3 pour ignorer deux valeurs après chaque itération.
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

Entrez dotnet run à partir de l’invite de commandes du Terminal pour exécuter votre code.
Notez comment la sortie a changé.

Lorsque vous exécutez le code, vous verrez la sortie suivante.
```
0
3
6
9
```
Certes, vous ne ferez pas ce genre de chose souvent, mais nous espérons que vous pouvez apprécier que vous avez un niveau de contrôle précis sur les itérations si vous en avez besoin.

Utiliser le mot clé break pour interrompre l’instruction d’itération

Qu’en est-il si nous devons quitter l’instruction d’itération prématurément en fonction d’une condition donnée ? Nous pouvons utiliser le break mot clé.

Utilisez Visual Studio Code Editor pour mettre à jour votre code comme suit :

for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
    if (i == 7) break;
}

Prenez une minute pour passer en revue l’utilisation du break mot clé dans votre code mis à jour.

Nous avons d’abord vu le break mot clé dans le module « Brancher le flux de code à l’aide de la construction switch-case en C# ». Comme il s’avère, nous pouvons également utiliser le break mot clé pour quitter les instructions d’itération.
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

Entrez dotnet run à partir de l’invite de commandes du Terminal pour exécuter votre code.
Notez comment la sortie a changé.

Lorsque vous exécutez le code, vous verrez la sortie suivante.
```
0
1
2
3
4
5
6
7
```

Parcourir chaque élément d’un tableau

Une utilisation courante de l’instruction for consiste à itérer dans un tableau d’éléments, en particulier si vous avez besoin d’un contrôle sur la façon dont l’itération se produit. Bien que le foreach parcourt chaque élément du tableau, la phrase for peut être ajustée pour offrir davantage de possibilités de personnalisation.

Utilisez Visual Studio Code Editor pour mettre à jour votre code comme suit :

string[] names = { "Alex", "Eddie", "David", "Michael" };
for (int i = names.Length - 1; i >= 0; i--)
{
    Console.WriteLine(names[i]);
}

Prenez une minute pour passer en revue votre code mis à jour.

Tout d’abord, notez que nous avons instancié un tableau de chaînes nommé names qui contient quatre noms.

Notez ensuite que nous utilisons la Array.Length propriété pour obtenir le nombre d’éléments dans le tableau et que nous utilisons cette valeur pour initialiser notre variable d’itérateur (int i = names.Length - 1). Nous soustractions 1 de la valeur, car le numéro d’index des éléments de tableau est de base zéro (les nombres d’index des quatre éléments sont 0-3).

Enfin, notez que nous avons choisi de parcourir le tableau en sens inverse—quelque chose que nous ne sommes pas en mesure de faire avec l’instruction foreach. Nous utilisons la valeur de la variable d’itération à l’intérieur du bloc de code pour spécifier le numéro d’index des éléments de tableau (names[i]).
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

Entrez dotnet run à partir de l’invite de commandes du Terminal pour exécuter votre code.
Notez que les éléments de tableau sont répertoriés dans l’ordre inverse (comme prévu).

Lorsque vous exécutez le code, vous verrez la sortie suivante.
```
Michael
David
Eddie
Alex
```
Remarque

Nous aurions pu itérer en avant dans les éléments du tableau en écrivant l'instruction for comme suit : for (int i = 0; i < names.Length; i++).

Examiner la limitation de l’instruction foreach

Que se passe-t-il si vous souhaitez mettre à jour une valeur dans le tableau pendant une foreach itération ?

Utilisez Visual Studio Code Editor pour mettre à jour votre code comme suit :

string[] names = { "Alex", "Eddie", "David", "Michael" };
foreach (var name in names)
{
    // Can't do this:
    if (name == "David") name = "Sammy";
}

Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

Entrez dotnet run à partir de l’invite de commandes du Terminal pour exécuter votre code.
Notez le message d’erreur affiché.

Si vous tentez de compiler et d’exécuter ce code, vous verrez une exception.
```
Cannot assign to name because it is a 'foreach iteration variable'
```
En d’autres termes, vous ne pouvez pas réaffecter la valeur name , car elle fait partie de l’implémentation interne de l’itération foreach .

Contournement de la limitation de l’instruction foreach avec l’instruction for

Essayons d’utiliser une for instruction pour modifier le contenu d’un tableau à l’intérieur du bloc de code d’itération.

Utilisez Visual Studio Code Editor pour mettre à jour votre code comme suit :

string[] names = { "Alex", "Eddie", "David", "Michael" };
for (int i = 0; i < names.Length; i++)
    if (names[i] == "David") names[i] = "Sammy";

foreach (var name in names) Console.WriteLine(name);

Prenez une minute pour passer en revue votre code mis à jour.

Notez que nous avons supprimé les accolades des blocs de code qui ne contenaient qu’une seule ligne de code. Cette révision utilise la même technique que celle dont nous avons parlé dans le module « Étendue et logique de la variable de contrôle à l’aide de blocs de code en C# ». De nombreux développeurs trouvent ce style difficile à lire, tandis que d’autres préfèrent ce style abrégé parce qu’il les aide à écrire plus succinctement et plus expressif. Si vous trouvez ce code difficile à lire ou que vous n’aimez pas simplement ce style, sachez que vous pouvez toujours utiliser des accolades dans vos blocs de code. Si vous le souhaitez, mettez à jour le code dans le panneau Éditeur avec le code suivant :
```
string[] names = { "Alex", "Eddie", "David", "Michael" };

for (int i = 0; i < names.Length; i++)
{
    if (names[i] == "David")
    {
        names[i] = "Sammy";
    }
}

foreach (var name in names)
{
    Console.WriteLine(name);
}
```
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

Entrez dotnet run à partir de l’invite de commandes du Terminal pour exécuter votre code.
Notez que le code s’exécute sans erreur et génère la sortie souhaitée.

Lorsque vous exécutez le code, vous verrez la sortie suivante.
```
Alex
Eddie
Sammy
Michael
```
Étant donné que le tableau ne fait pas directement partie de l’implémentation de l’instruction d’itération, vous pouvez modifier les valeurs à l’intérieur du tableau.

Récapitulatif

Voici quelques-uns des points importants de cette unité :

L’instruction for d’itération vous permet d’effectuer une itération via un bloc de code un nombre spécifique de fois.
L’instruction for d’itération vous permet de contrôler chaque aspect de la mécanique de l’itération en modifiant les trois conditions entre parenthèses : l’initialiseur, la condition et l’itérateur.
Il est courant d’utiliser l’instruction for lorsque vous devez contrôler la façon dont vous souhaitez effectuer une itération dans chaque élément d’un tableau.
Si votre bloc de code n’a qu’une seule ligne de code, vous pouvez éliminer les accolades et les espaces blancs si vous le souhaitez.

Commentaires

Cette page a-t-elle été utile ?

Exercice - Créer et configurer des boucles d’itération for

Vérification des connaissances

Commentaires