Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Apprendre Boucle For | Boucles
Bases de C#

bookBoucle For

Une boucle permet d'exécuter un morceau de code autant de fois que nécessaire. Il existe différents types de boucles. En C#, si l'on souhaite exécuter un morceau de code un nombre précis de fois, on utilise la for loop.

Le modèle (syntaxe) d'une boucle for est le suivant :

for(initiation; condition; operation) { 
    // code to execute
}


Considérons un exemple utilisant cette syntaxe :

main.cs

main.cs

copy

              
123456789101112131415

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			// Output "Hello World" ten times.
			for(int i = 0; i < 10; i++) {
    			Console.WriteLine("Hello World");
			}
        }
    }
}

Remarque

i++ est équivalent à i = i + 1. Cela incrémente la valeur de la variable de 1. De même, i-- décrémente la valeur de 1.

  • int i = 0 correspond à la partie d'initialisation. L'initialisation a lieu au démarrage de la boucle. Au début de la boucle, une nouvelle variable temporaire appelée i est créée et initialisée à la valeur 0.
  • i < 10 est la condition. La condition est vérifiée à chaque itération (répétition) de la boucle. La boucle continue d'exécuter le bloc de code tant que la condition est vraie.
  • i++ est l'opération à effectuer après chaque itération. L'opération consiste généralement en une incrémentation ou une décrémentation. Comme la valeur de i est incrémentée après chaque itération, la condition i < 10 devient fausse après 10 itérations, et la boucle s'arrête.

Il est important de comprendre que les trois composants de la boucle for — initialization, condition et operation — sont facultatifs. Vous pouvez en omettre certains, mais cela peut modifier le comportement de la boucle.

Bien que cela ne soit pas recommandé, il est possible de déclarer la variable de boucle en dehors de la boucle et de laisser la partie initialization vide. La boucle fonctionnera toujours, mais il faut être vigilant car cela peut entraîner des résultats inattendus si ce n'est pas géré correctement.

main.cs

main.cs

copy

              
12345678910111213141516

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			int i = 0;
			for(; i < 10; i++)
			{
			    Console.WriteLine("Hello World");
			}
        }
    }
}

Il est également possible de supprimer la partie operation et de la placer à la fin du bloc de code de la boucle. La boucle se comportera de la même manière, car la variable i sera toujours incrémentée après chaque itération.

main.cs

main.cs

copy

              
1234567891011121314151617

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			int i = 0;
			for(; i < 10;)
			{
    			Console.WriteLine("Hello World");
    			i++;
			}
        }
    }
}

Notez que dans le code ci-dessus, nous avons tout de même placé un point-virgule (;) dans la syntaxe de la boucle à l'endroit où l'on attendait int i = 0. Ce point-virgule doit toujours être présent, que l'on crée ou non une variable de boucle.

Il est également possible de supprimer la condition de la boucle, mais cela rend la boucle infinie si elle n'est pas arrêtée manuellement (ce que nous aborderons dans les chapitres suivants).

main.cs

main.cs

copy

              
1234567891011121314151617

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			// In this case the variable `i` is useless so we don't create it.
				// The loop never ends
				for(;;)
				{
				    Console.WriteLine("Hello World");
				}
        }
    }
}

Remarque

Nous avons tout de même inclus les deux points-virgules dans la syntaxe de la boucle for(;;), ceux-ci sont essentiels, sinon le compilateur affichera des erreurs.

Comme la valeur de i change à chaque itération, il est possible de l'utiliser à notre avantage. Pour comprendre cela, examinons un programme simple qui affiche la valeur de i à chaque itération :

main.cs

main.cs

copy

              
123456789101112131415

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			for(int i = 0; i < 10; i++)
			{
			    Console.WriteLine(i);
			}
        }
    }
}

Remarquez que cela se termine à 9 car cela commence avec le chiffre 0. Le nombre total d'itérations était de dix. Il est possible de modifier l'initialisation, la condition et l'opération pour afficher les dix nombres pairs de 2 à 20.

Remarque

Les nombres pairs sont les nombres divisibles par 2. Par exemple : 2, 4, 6, 8, 10, etc. Les nombres pairs incluent également le nombre 0, mais nous ne traiterons que les nombres pairs supérieurs à 0 dans ces exemples.

main.cs

main.cs

copy

              
123456789101112131415

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			for(int i = 2; i <= 20; i += 2)
			{
			    Console.WriteLine(i);
			}
        }
    }
}

Remarque

i += 2 est une manière abrégée d'écrire i = i + 2. Cette syntaxe est également valable pour d'autres opérateurs, par exemple i -= 2, i *= 2, i /= 2, i %= 2, etc.

La boucle commence à 0 et augmente la valeur de i de 2 à chaque itération. Nous avons modifié la condition en i <= 20 afin que la boucle s'arrête à 20.

La logique ci-dessus sert à comprendre le fonctionnement d'une boucle for. Une logique beaucoup plus simple peut être utilisée pour afficher les dix premiers nombres pairs :

main.cs

main.cs

copy

              
1234567891011121314

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			for(int i = 1; i <= 10; i++) {
    			Console.WriteLine(i * 2);
			}
        }
    }
}

Dans ce cas, la condition est beaucoup plus simple. Par exemple, si nous voulons les 27 premiers nombres pairs, il faudrait connaître le 27ème nombre pair pour pouvoir former la condition dans la méthode précédente. Cependant, ici, il suffit simplement de modifier la condition en i <= 27 :

main.cs

main.cs

copy

              
1234567891011121314

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			for(int i = 1; i <= 27; i++) {
			    Console.WriteLine(i * 2);
			}
        }
    }
}
question mark

Quelle sera la sortie du programme suivant ? La valeur de sum augmente à chaque itération de i, donc sa valeur pendant les quatre premières itérations sera : 1, 3, 6, 10.

Select the correct answer

Tout était clair ?

Comment pouvons-nous l'améliorer ?

Merci pour vos commentaires !

Section 4. Chapitre 1

Demandez à l'IA

expand

Demandez à l'IA

ChatGPT

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you explain more about the different types of loops in C#?

What happens if I omit all three components in the for loop?

Can you show an example of a for loop that runs infinitely?

Awesome!

Completion rate improved to 1.59

bookBoucle For

Glissez pour afficher le menu

Une boucle permet d'exécuter un morceau de code autant de fois que nécessaire. Il existe différents types de boucles. En C#, si l'on souhaite exécuter un morceau de code un nombre précis de fois, on utilise la for loop.

Le modèle (syntaxe) d'une boucle for est le suivant :

for(initiation; condition; operation) { 
    // code to execute
}


Considérons un exemple utilisant cette syntaxe :

main.cs

main.cs

copy

              
123456789101112131415

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			// Output "Hello World" ten times.
			for(int i = 0; i < 10; i++) {
    			Console.WriteLine("Hello World");
			}
        }
    }
}

Remarque

i++ est équivalent à i = i + 1. Cela incrémente la valeur de la variable de 1. De même, i-- décrémente la valeur de 1.

  • int i = 0 correspond à la partie d'initialisation. L'initialisation a lieu au démarrage de la boucle. Au début de la boucle, une nouvelle variable temporaire appelée i est créée et initialisée à la valeur 0.
  • i < 10 est la condition. La condition est vérifiée à chaque itération (répétition) de la boucle. La boucle continue d'exécuter le bloc de code tant que la condition est vraie.
  • i++ est l'opération à effectuer après chaque itération. L'opération consiste généralement en une incrémentation ou une décrémentation. Comme la valeur de i est incrémentée après chaque itération, la condition i < 10 devient fausse après 10 itérations, et la boucle s'arrête.

Il est important de comprendre que les trois composants de la boucle for — initialization, condition et operation — sont facultatifs. Vous pouvez en omettre certains, mais cela peut modifier le comportement de la boucle.

Bien que cela ne soit pas recommandé, il est possible de déclarer la variable de boucle en dehors de la boucle et de laisser la partie initialization vide. La boucle fonctionnera toujours, mais il faut être vigilant car cela peut entraîner des résultats inattendus si ce n'est pas géré correctement.

main.cs

main.cs

copy

              
12345678910111213141516

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			int i = 0;
			for(; i < 10; i++)
			{
			    Console.WriteLine("Hello World");
			}
        }
    }
}

Il est également possible de supprimer la partie operation et de la placer à la fin du bloc de code de la boucle. La boucle se comportera de la même manière, car la variable i sera toujours incrémentée après chaque itération.

main.cs

main.cs

copy

              
1234567891011121314151617

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			int i = 0;
			for(; i < 10;)
			{
    			Console.WriteLine("Hello World");
    			i++;
			}
        }
    }
}

Notez que dans le code ci-dessus, nous avons tout de même placé un point-virgule (;) dans la syntaxe de la boucle à l'endroit où l'on attendait int i = 0. Ce point-virgule doit toujours être présent, que l'on crée ou non une variable de boucle.

Il est également possible de supprimer la condition de la boucle, mais cela rend la boucle infinie si elle n'est pas arrêtée manuellement (ce que nous aborderons dans les chapitres suivants).

main.cs

main.cs

copy

              
1234567891011121314151617

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			// In this case the variable `i` is useless so we don't create it.
				// The loop never ends
				for(;;)
				{
				    Console.WriteLine("Hello World");
				}
        }
    }
}

Remarque

Nous avons tout de même inclus les deux points-virgules dans la syntaxe de la boucle for(;;), ceux-ci sont essentiels, sinon le compilateur affichera des erreurs.

Comme la valeur de i change à chaque itération, il est possible de l'utiliser à notre avantage. Pour comprendre cela, examinons un programme simple qui affiche la valeur de i à chaque itération :

main.cs

main.cs

copy

              
123456789101112131415

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			for(int i = 0; i < 10; i++)
			{
			    Console.WriteLine(i);
			}
        }
    }
}

Remarquez que cela se termine à 9 car cela commence avec le chiffre 0. Le nombre total d'itérations était de dix. Il est possible de modifier l'initialisation, la condition et l'opération pour afficher les dix nombres pairs de 2 à 20.

Remarque

Les nombres pairs sont les nombres divisibles par 2. Par exemple : 2, 4, 6, 8, 10, etc. Les nombres pairs incluent également le nombre 0, mais nous ne traiterons que les nombres pairs supérieurs à 0 dans ces exemples.

main.cs

main.cs

copy

              
123456789101112131415

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			for(int i = 2; i <= 20; i += 2)
			{
			    Console.WriteLine(i);
			}
        }
    }
}

Remarque

i += 2 est une manière abrégée d'écrire i = i + 2. Cette syntaxe est également valable pour d'autres opérateurs, par exemple i -= 2, i *= 2, i /= 2, i %= 2, etc.

La boucle commence à 0 et augmente la valeur de i de 2 à chaque itération. Nous avons modifié la condition en i <= 20 afin que la boucle s'arrête à 20.

La logique ci-dessus sert à comprendre le fonctionnement d'une boucle for. Une logique beaucoup plus simple peut être utilisée pour afficher les dix premiers nombres pairs :

main.cs

main.cs

copy

              
1234567891011121314

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			for(int i = 1; i <= 10; i++) {
    			Console.WriteLine(i * 2);
			}
        }
    }
}

Dans ce cas, la condition est beaucoup plus simple. Par exemple, si nous voulons les 27 premiers nombres pairs, il faudrait connaître le 27ème nombre pair pour pouvoir former la condition dans la méthode précédente. Cependant, ici, il suffit simplement de modifier la condition en i <= 27 :

main.cs

main.cs

copy

              
1234567891011121314

            
using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
			for(int i = 1; i <= 27; i++) {
			    Console.WriteLine(i * 2);
			}
        }
    }
}
question mark

Quelle sera la sortie du programme suivant ? La valeur de sum augmente à chaque itération de i, donc sa valeur pendant les quatre premières itérations sera : 1, 3, 6, 10.

Select the correct answer

Tout était clair ?

Comment pouvons-nous l'améliorer ?

Merci pour vos commentaires !

Section 4. Chapitre 1
some-alt