C-SHARP - 3.12 Boucle For et Foreach

Suite de la démo sur Visual Studio pour pratiquer les boucles for et foreach en C#. La différence avec la boucle while est essentiellement syntaxique : au lieu d'initialiser le compteur avant la boucle et d'incrémenter cette variable à l'intérieur du bloc, on regroupe tout — initialisation, condition et incrémentation — entre les parenthèses du for.

La boucle for

Pour écrire une boucle for qui parcourt notre tableau tab_prenom, on déclare directement la variable de boucle entre parenthèses, on définit la condition de poursuite, puis l'incrémentation. Chaque expression est séparée par un point-virgule :

for (int compteur = 0; compteur < tab_prenom.Length; compteur++)
{
    Console.WriteLine(tab_prenom[compteur]);
}

Le résultat est identique à celui de la boucle while, mais le code est plus clair et plus compact. On a aussi moins de risques de tomber dans une boucle infinie puisque l'incrémentation est posée d'emblée dans la signature de la boucle. Le choix entre while et for reste du cas par cas selon la situation.

La boucle foreach

La boucle foreach fonctionne différemment : pas d'index ni de compteur. Elle parcourt directement chaque élément de la collection. La syntaxe : foreach, parenthèses, déclaration d'une variable du même type que les éléments parcourus, mot-clé in, puis la collection à itérer.

foreach (string unPrenom in tab_prenom)
{
    Console.WriteLine(unPrenom);
}

À chaque tour, la variable unPrenom reçoit l'élément courant : la première valeur du tableau au premier tour, la deuxième au deuxième tour, et ainsi de suite. Comme unPrenom représente déjà une valeur du tableau, c'est elle que l'on passe à Console.WriteLine, sans avoir à manipuler d'index. Lancer le programme affiche bien tous les prénoms.

Ces trois types de boucles couvrent la majorité des besoins de parcours en C#. Si certains points restent flous, n'hésitez pas à revisionner les vidéos précédentes. La prochaine vidéo proposera un exercice pour consolider la maîtrise de ces notions de boucles.

En résumé

Cette leçon compare deux structures de boucle fondamentales en C# : la boucle `for` et la boucle `foreach`. La boucle `for` combine l'initialisation d'une variable compteur, une condition de test et l'incrémentation dans les parenthèses, offrant un code plus compact et sécurisé que `while`. La boucle `foreach` simplifie l'itération en accédant directement à chaque élément du tableau sans gestion d'index, ce qui rend le code plus lisible et diminue le risque de boucles infinies.

Points clés

• La boucle `for` regroupe l'initialisation, la condition et l'incrémentation en une seule ligne, contrairement à `while` où ces éléments sont dispersés
• La boucle `foreach` itère directement sur chaque élément du tableau sans accès par index, rendant le code plus simple et lisible
• Syntaxe `for` : `for(int compteur = 0; compteur < array.Length; compteur++)` pour parcourir un tableau avec index
• Syntaxe `foreach` : `foreach(string prenom in tableau)` où la variable récupère automatiquement chaque valeur du tableau
• Les boucles `for` et `foreach` produisent les mêmes résultats qu'une boucle `while`, mais avec moins de risques d'erreur et un code plus clair
• Le choix entre `while`, `for` et `foreach` dépend du contexte, mais `foreach` est privilégié pour itérer simplement sur une collection

Questions fréquentes

Quelle est la différence principale entre la boucle `for` et la boucle `while`?

La boucle `for` centralise l'initialisation, la condition et l'incrémentation dans ses parenthèses, tandis que `while` oblige à initialiser et incrémenter manuellement avant et à l'intérieur de la boucle. Cela rend `for` plus compacte et réduit les risques de boucle infinie.

Quand utiliser `foreach` plutôt que `for` en C#?

Utilisez `foreach` quand vous avez besoin de parcourir tous les éléments d'une collection sans avoir besoin d'accéder à l'index. Elle simplifie le code car la variable reçoit automatiquement chaque valeur du tableau à chaque tour de boucle.

Pourquoi `foreach` est-elle plus sûre que `for` ou `while`?

`foreach` élimine les risques de boucle infinie et d'erreurs d'index en itérant directement sur les éléments. Il n'y a pas de gestion manuelle de compteur ou de condition, ce qui rend le code plus simple à comprendre et à déboguer.