Apprenez à programmer en C#

Imaginez que vous ayez un bloc de code que vous devez répéter plusieurs fois. Vous pourriez très bien l'intégrer dans une fonction que vous appelleriez autant de fois que nécessaire. Le problème, c'est que la plupart du temps, vous ne saurez pas à l'avance combien de fois vous devrez l'appeler.

C’est pour cela que les boucles existent !

En programmation, une boucle est une technique qui permet de répéter une ou plusieurs instructions sans avoir à retaper le même ensemble d'instructions plusieurs fois.

Utilisez des boucles d'énumération pour un nombre connu d'itérations

Les boucles d'énumération sont utiles lorsque vous savez à l'avance combien de fois vous voulez répéter une itération. En C#, on parle de boucles for.

Avec elles, vous pouvez indiquer le nombre d'itérations à effectuer :

1. En tant que valeur entière.

2. En tant que résultat d'une expression qui génère une valeur entière.

Boucles for avec une valeur entière

Voici un exemple de boucle for qui répète une instruction cinq fois :

for (int i = 0; i < 5; i++)
{
   Console.WriteLine("Applaudissez !");
}

Dans cet ensemble d'instructions, nous avons une variable d'énumération  i  qui est responsable du comptage des exécutions. Le code équivalent sans utiliser de boucle serait :

Console.WriteLine("Applaudissez !");
Console.WriteLine("Applaudissez !");
Console.WriteLine("Applaudissez !");
Console.WriteLine("Applaudissez !");
Console.WriteLine("Applaudissez !");

La syntaxe générale de l'instruction for est la suivante :

for (valeur de début; valeur de fin; incrément)
{
    // Code à répéter
}

1.  La valeur de début est une expression qui marque le début de la boucle. Elle déclare et assigne généralement un itérateur. Dans notre exemple, nous déclarons un itérateur nommé  i  de type  int  avec une valeur de  0  .

2. La valeur de fin est l’expression qui est évaluée avant chaque exécution de la boucle. Si elle est fausse, la boucle s'arrête. Dans notre exemple, la valeur de fin est  i < 5  , ce qui signifie que la boucle s'arrête lorsque  i  atteint la valeur cinq.

3. Un incrément est une expression qui est évaluée chaque fois qu'une itération de la boucle est effectuée. Dans notre exemple, l'incrément est  i++  . Cela signifie que nous ajoutons  1  à la valeur de  i  à chaque fois que nous exécutons la boucle.

4. La liste des instructions est située entre  {  et  }  . C'est le code qui est exécuté chaque fois que la boucle est exécutée.

Boucles for avec les collections

Vous pouvez utiliser les boucles d'énumération si vous avez besoin d'effectuer une itération sur un array ou une collection. Voici un exemple pour les arrays :

int[] monArray = new int[]{7, 2, 4};

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

Dans la première partie de notre cours, nous avons vu qu'un array possède une propriété  Length  qui renvoie le nombre d’éléments de cet array. Dans cet exemple, ce nombre est utilisé comme valeur de fin de la boucle for. Parfois, on ne veut pas spécifier explicitement combien de fois la boucle doit tourner, mais juste afficher l'ensemble des valeurs contenues dans l'array ou la collection. Pour ce cas de figure, C# fournit une instruction appelée  foreach  . Sa syntaxe est la suivante :

foreach (int nombre in monArray)
{
    Console.WriteLine(nombre);
}

Avec la boucle  foreach  , il vous suffit de définir une variable du type de l'array ou de la collection que vous souhaitez mettre en boucle. Cette variable se verra attribuer la valeur de chaque élément de l'array ou de la collection jusqu'à ce que vous ayez atteint la fin.

La boucle for est idéale si vous voulez faire une boucle avec un nombre prédéfini de tours, ou sur tous les éléments d'un array. Si cela n'est pas le cas, C# fournit un type de boucle plus général : les boucles conditionnelles.

Répétez une boucle jusqu'à atteindre une condition avec while

Les boucles conditionnelles sont également appelées boucles while. Il en existe deux types :

1. while.

2. do/while.

Dans ce cas, la boucle doit continuer tant que la condition du while reste vraie. Cela revient à associer la boucle for à une instruction if. Le nombre de répétitions n'est pas défini par les limites inférieure et supérieure d'un énumérateur, mais par une condition telle que celle d'une instruction if.

Boucle while

Voici à quoi ressemble la syntaxe d'une boucle while :

while (expressionLogique)
{
    // Liste d'instructions
}

Elle peut être interprétée comme « tant que l'expression logique est vraie, répétez les instructions ».

Voici comment cela fonctionne en détail :

1. Le programme vérifie que  expressionLogique  est vraie. 

2. Si l’expression est fausse , les instructions sont ignorées. Vous n'entrez même pas dans le corps de la boucle située entre  {  et  }  .

3. Si l'expression est vraie, les instructions à l'intérieur de  {  et  }  sont exécutées.

4. Une fois les instructions exécutées, vous revenez à la première étape.

Voyons un exemple concret :

int nombreArbres = 0;

while (nombreArbres < 10)
{
    nombreArbres += 1;
    Console.WriteLine("J’ai planté " + nombreArbres + "arbres");
}

Console.WriteLine("Je possède une forêt !");

Ce code donnera le résultat suivant :

J’ai planté 1 arbres
J’ai planté 2 arbres
J’ai planté 3 arbres
J’ai planté 4 arbres
J’ai planté 5 arbres
J’ai planté 6 arbres
J’ai planté 7 arbres
J’ai planté 8 arbres
J’ai planté 9 arbres
J’ai planté 10 arbres
Je possède une forêt !

À chaque itération, la variable  nombreArbres  est incrémentée de 1. Lorsqu'elle atteint la valeur  10  , la condition   nombreArbres  <  10  n'est plus vraie. Par conséquent, la boucle se termine, et la suite du programme est exécutée. Dans ce cas, le programme affiche «  Je possède une forêt !  ».

Voici un exemple de boucle infinie :

bool soleilLeve = true;

while (soleilLeve)
{
    Console.WriteLine("Restez éveillé... pour toujours !");
    // La variable soleilLeve ne change jamais
}

// Nous n’atteindrons jamais cette partie
Console.WriteLine("Allez dormir !");

C'est une erreur courante et facile à commettre. Alors, faites attention !

Comme vous pouvez le voir, la condition while est vérifiée avant même que le bloc de code correspondant puisse être exécuté une seule fois !

Boucle do... while

La boucle do... while est très similaire à celle que nous venons de voir, mais la condition est cette fois-ci placée à la fin du bloc de code. De cette façon, le bloc de code sera toujours exécuté au moins une fois.

Voici à quoi ressemble la syntaxe :

do
{
    // Instructions
} while (expressionLogique);

Prenons un exemple :

int objectifPompe = 10;

do
{
    Console.WriteLine("Une pompe !");
    objectifPompe -= 1;
} while (objectifPompe > 0);

De cette façon, au moins une pompe est faite avant que la condition soit vérifiée. Modifions cet exemple pour montrer la différence par rapport à la boucle while d'origine :

Prenons un exemple :

// Boucle « While »
int objectifPompe = 0;

while(objectifPompe > 0)
{
    Console.WriteLine ("Une pompe !");
    objectifPompe -= 1;
}

// Boucle « do/While »
int objectifPompe = 0;

do
{
    Console.WriteLine ("Une pompe !");
    objectifPompe -= 1;
} while (objectifPompe > 0);

Vous pouvez voir qu'avec la boucle while d'origine, aucune pompe n'est réalisée. Avec la boucle do/while, une pompe sera effectuée.

Ignorez quelques instructions à l'intérieur d'une boucle

Dans chaque type de boucle, vous pouvez vouloir sauter certaines itérations ou interrompre toute la boucle prématurément à une certaine condition.

Par exemple, vous pouvez vouloir répéter quelque chose 10 fois, mais ignorer totalement ou partiellement l'action si la valeur est égale à  2  ou  5  . En C#, pour ignorer une itération dans une boucle, utilisez une instruction  continue  :

for (int i = 0; i < 10; i++)
{
    // Déclarations exécutées à chaque itération
    if (i == 2 || i == 5)
    {
        continue;
    }
    // Instructions non exécutées lorsque i == 2 ou 5
}

Vous pouvez également interrompre complètement la séquence, par exemple si vous recherchez un élément dans un array et arrêtez votre recherche une fois cet élément trouvé :

En C#, pour interrompre une séquence d'exécution, utilisez l'instruction  break  :

string[] panier = new string[] {"pomme", "orange", "banane"};

for (int i = 0; i < panier.Length; i++
{
    if (panier[i] == "orange")
    {
        Console.WriteLine ("J'ai une " + panier[i] + " !");
        break;
    }
}

Une fois que vous avez trouvé l’élément que vous recherchiez, arrêtez de parcourir l'array.

Testez par vous-même !

Prêt à coder ? Pour accéder à l’exercice, suivez ce lien. 

En résumé 

Dans ce chapitre, vous avez découvert deux types de boucles :

• Les boucles d'énumération exécutent un ensemble d'instructions un nombre de fois donné, en fonction des valeurs limites inférieure et supérieure de l'énumérateur.

• Les boucles conditionnelles exécutent un ensemble d'instructions jusqu'à ce qu'une condition définie soit remplie.

• Méfiez-vous d'une erreur courante avec les boucles conditionnelles : les boucles infinies !

• Les itérations d'une boucle peuvent ignorer certaines instructions à l'intérieur de la boucle en utilisant la commande  continue  .

• Le cycle d'une boucle peut être interrompu, et la boucle peut être interrompue prématurément à l'aide de la commande  break   .