Qu'est-ce qu'une boucle ?

Une boucle c'est deux lignes spéciales et tout ce qui est au milieu va être répété un certain nombre de fois, car après tout une boucle ça sert à ... boucler ! Merci ceux du fond !

Mais en programmation il existe de nombreuses manières de faire des boucles et je vais essayer de vous les détailler dans ce petit tutoriel.


Tant que ... Faire ...


Cette boucle est la plus basique elle s'utilise en général de la manière suivante :
while(condition){
     instructions
}


Et ça veut dire :
Tant que condition est vraie Faire
     instructions
FinFaire

En gros, aussi longtemps que la condition sera vérifiée alors les instructions seront exécutées encore et encore.

Exemple concret :
J'ai un compteur qui est initialisé à 0.
Et je fais une boucle qui dit "Tant que mon compteur est inférieur à 10 on va ajouter 1 à mon compteur".

compteur reçoit 0
Tant que compteur < 10 Faire
     compteur reçoit compteur + 1
FinFaire

Blague :
On va dire que la condition de poursuite de boucle (ou condition d'arrêt dans notre jargon) est : "1 est égal à 1".
"Mais mais c'est toujours vrai ça, non ?", En effet.
"Mais alors à chaque fois que les instructions sont finies la condition est toujours vraie ?", Oui oui.
"Mais la boucle recommencera encore ?", c'est toujours ça.
"Mais ça n'a pas de fin !", exactement là où je voulais en venir.

Vous venez de voir "la boucle infinie" !! Très peu utilisée elle sert parfois. Et je ne peux que vous conseiller de ne pas l'utiliser et pour éviter d'en faire de bien vérifier votre condition d'arrêt.

"Ouaaa alors c'est ça qui fait bloquer et tout ralentir ?!?" et oui.
Il y a d'autres manière d'en faire : des simples, des complexes, avec d'autres types de boucles, ... Je ne vais pas les détailler à chaque fois sauf si vous le demandez gentiment (demandez par pitié ...).


Répéter ... Tant que ... ou Répéter ... Jusqu'à ce que ...


Elle est très proche de tant que faire mais avec une différence expliquée plus bas.
Elle s'utilise en général de cette manière :
do{
     instructions
}while(condition)


Traduction :
Répéter
     instructions
Tant que condition est vraie

"Mais c'est quoi la différence avec la première ???" La position de la condition. Je m'explique :
"Tant que la condition est vraie alors répéter la boucle" si la condition est fausse dès le départ la boucle ne sera pas exécutée du tout. "Répéter la boucle tant que la condition est vraie" peut se traduire et est plus explicite avec "Répéter la boucle jusqu'à ce que la condition soit fausse". Je sais le vrai ou faux peut gêner au niveau du sens, mais elle reste plus compréhensible. Au final la boucle est exécutée et si la condition est fausse on arrête de tourner, mais la boucle aura été exécutée au moins une fois.

"Mais je comprends pas l'utilité d'avoir deux boucles comme ça."
Exemple concret :
"Veuillez saisir un entier supérieur à 0 : "
Vous tapez.
Le programme réfléchit, voit que vous vous êtes trompé.
"Il y a une erreur"
"Veuillez saisir un entier supérieur à 0 : "
Elle est principalement utilisée dans des cas de calculs nécessitant une nouvelle exécution jusqu'à un résultat correct, voilà pourquoi il peut être préférable de dire "Répéter jusqu'à ce que la condition soit fausse" quitte peut être à la mélanger avec l'autre, car après tout "Tant que la condition est vraie on recommence".


Pour ... De ... A ... Avec un pas de ...


Dans les boucles précédentes les conditions des boucles que nous avons vues pouvait impliquer un nombre de "boucle" plus ou moins long voir même infini ou ne pas boucler une seule fois.
Le Pour a été créé pour faire des boucles ayant un nombre de boucles fini que l'on peut connaitre à l'avance.

Il s'écrit la plupart du temps en code comme :
for(compteur = valeur; condition avec compteur; opération avec compteur){
     instructions
}


Exemple :
for(compteur = 1; compteur <= 10; compteur = compteur + 1){
     instructions
}
Traduction :
Pour compteur De 0 A 10 Avec un pas de 1 Faire
     instructions
FinFaire

Traduction (enfin) :
Faire les instructions 10 fois.
"Ah enfin je ne comprenais plus rien" Désolé, mais il faut dire qu'elle est un peu moins simple que les précédentes.
Elle s'écrit donc en trois parties : une initialisation, une condition de sortie et une opération.

Détaillons la traduction pour bien comprendre :
"Pour compteur De 0 ..."
Initialisation : la variable compteur reçoit 0.
"... A 10 ..."
Condition de sortie: tant que (tiens ça me dit quelque chose ^^) la variable n'a pas atteint la valeur 10
"... Avec un pas de 1 ... "
Opération : la variable compteur reçoit 1 de plus que lors de la boucle précédente

Dans cette boucle la variable compteur aura comme valeur 1 dans la 1ère boucle, 2 dans la 2ème, ...
Ainsi la boucle tournera 10 fois, ni plus, ni moins. J'ai entendu une remarque plus haut avec le "tant que", en effet la condition d'arrêt est bien "tant que la condition est vraie". Il serait donc possible de réécrire cette boucle avec un Tant que Faire.

Transformation en Tant que Faire :
compteur reçoit 0
Tant que compteur <= 10 Faire
     instructions
     compteur reçoit compteur + 1
FinFaire

Les deux boucles font la même chose, mais elles sont différentes, vous pouvez utiliser les deux, mais il est préférable d'utiliser le "Pour" lorsque vous connaissez le nombre de tours à faire.


Etiquette ... et Aller à ...


Ces instructions permettent de faire des boucles, mais elles sont à la fois beaucoup plus simples que les autres et font quelque chose de spécial. Elles ne se trouvent pas dans tous les langages, mais je vous en parle car on en trouve encore.

Etiquette se traduit par Label
Aller à se traduit par Goto

Exemple :
instructions 1
Etiquette 1
instructions 2
Aller à 1

Aller à 2
instructions 3
Eiquette 2

C'est un simple exemple pour bien comprendre.
Etiquette ne fait rien de spécial à part indiquer qu'elle est là.
Aller à agit directement, elle demande au programme de "sauter" toutes les instructions du code et de reprendre à l'Etiquette 1

Dans l'exemple précédent, on fait instructions 1, on passe par Etiquette 1 sans rien faire, on fait instructions 2, on tombe sur Aller à Etiquette 1, on va à Etiquette 1, on fait instructions 2, on tombe sur Aller à Etiquette 1, on va à Etiquette 1, on fait instructions 2 et ainsi de suite sans avoir de fin. Donc dans cet exemple il serait judicieux de rajouter un test pour savoir si on exécute la ligne "Aller à".

Dans la deuxième partie de l'exemple on tombe sur Aller à l'étiquette 2, on s'y rend sans jamais exécuter instructions 3.
Comme expliqué leur fonctionnement est simple, mais leur utilisation est risquée, on se perd assez facilement, il est préférable de suivre toutes les instructions bien dans l'ordre, sans avoir à aller dans tous les sens dans le code.



Voilà j'espère avoir été assez clair n'hésitez pas à laisser des commentaires s'il y a des flous ou un manque de détails.