Les instructions répétitives avec For
Published: 2021-05-31 12:31:02

---
title: Les instructions répétitives avec For
published: true
description: 
tags: 
cover_image: https://media.geeksforgeeks.org/wp-content/uploads/20191108131134/For-Loop.jpg
---


Imaginez que vous ayez une partie du code que vous devez répéter plusieurs fois. Vous pouvez l’écrire autant de fois en mettant le même traitement dans le code. Cela pourrait faire l'affaire. Parfois vous ne connaissez pas la condition pour arrêter de faire ce traitement.
**Les boucles** permettent de résoudre ce problème !
En programmation, une boucle est une technique qui permet de répéter une ou plusieurs instructions sans avoir à écrire à nouveau le même ensemble d'instructions plusieurs fois.
Les itérations ( une boucle for) nous permette de répéter un traitement en bouclant ou itérant.
L'instruction boucle for permet d'exécuter un traitement de manière répétitive, mais en spécifiant différemment la condition d'arrêt. La boucle for définit trois types d’instructions séparées par des points-virgules. La première déclaration est la déclaration d’initialisation. La seconde définit la condition de terminaison. La dernière déclaration est la clause de mise à jour. 
Si on veut exécuter une instruction ou un bloc de code un nombre précis et connu de fois, on va préférer utiliser l'instruction **for**. 
```java
 System.out.println(1);
 System.out.println(2);
 System.out.println(3);
 System.out.println(4);
 System.out.println(5);
 System.out.println("Done");
```
Commençons avec le même exemple que précédemment, c'est-à-dire le programme qui affiche les nombres entiers de 1 à 5, mais faisons le avec l'instruction for : 
```java
for (int i = 1; i <= 5; i++) {
   System.out.println(i);
}
System.out.println("Done");
```
l'instruction **for** commence par le mot réservé for suivi de trois éléments séparés par des points-virgules, le tout mis entre parenthèses, suivi du le corps de la boucle. 
```java
for (initialization; condition; increment/decrement)
```
Une variable de compteur est utilisée dans toutes ces parties. Cette variable garde la trace de la répétition en cours, et est typiquement nommée **i**.
La partie d'initialisation initialise la variable de compteur à une valeur de départ.
Dans ce cas (**int i = 1**), la valeur initiale est 1.
La partie condition indique à l'ordinateur s'il doit continuer à répéter ou non. L'ordinateur évalue la condition à chaque fois, et si l'expression est vraie, il exécute les instructions intérieures. Dans le cas contraire, il sort entièrement de la boucle.
Dans ce cas (**i <= 5**), la condition vérifie si la variable compteur est inférieure ou égale à 5.
La partie incrémentation/décrémentation modifie la variable du compteur après chaque répétition.

La boucle la plus courante que vous verrez en programmation commencera à 0, s'arrêtera avant un certain nombre et s'incrémentera de un à chaque fois. Cependant, en variant les parties de la boucle, nous pouvons créer des boucles qui se répètent de nombreuses autres façons.
Par exemple, ce programme utilise une boucle for pour décompter de 10 à 1 :
```java
for (int i = 10; i > 0; i--) {
   System.out.println(i);
}
```
Remarquez les différences :
- Dans l'initialisation, nous donnons à la variable compteur la valeur 10.
- Dans la condition, nous vérifions si la variable compteur est supérieure à 0. 
- Cela signifie que la dernière répétition aura lieu lorsque la variable compteur sera égale à 1, et l'ordinateur quittera alors la boucle.
- Dans la dernière partie, nous diminuons de 1 la variable compteur.

Voici un autre exemple, une boucle for qui affiche les nombres pairs de 0 à 40 :
```java
for (int i = 0; i <= 40; i += 2) {
    System.out.println(i);
}
```
Cette boucle démarre à 0, mais diffère autrement :
La condition vérifie si la variable compteur est inférieure ou égale à 40. Cela signifie que cette boucle affichera 40. Si elle était seulement inférieure à, elle s'arrêterait à 39.
La dernière partie ajoute 2 à la variable compteur, et non 1 comme d'habitude.
La flexibilité de la boucle for signifie que nous pouvons programmer de nombreux types de répétitions avec elle. Mais attention, cette flexibilité facilite aussi les erreurs ! 

###Boucles imbriquées
Une boucle imbriquée nous permet de répéter selon deux dimensions.
Explorons cela dans un exemple de codage. Que faire si nous devons apprendre tous les tables de multiplication des chiffres de 1 à 10 ? Les boucles imbriquées à la rescousse !
```java
for (int i = 1; i <= 10; i++) {
  for (int j = 1; j <= 10; j++) {
    System.out.println(i+"x"+j+"="+ i * j);
  }
}
```

Dans notre prochain cours, on va voir une autre manière de faire une instruction répétitive. Pour le moment, vous pouvez rendre plus joli l'affichage du résultat. A vous de jouer.