Dart en 10 chapitres : Chap 4 Boucles.
Salut, j’espère que vous vous portez bien.
0. Vue d’ensemble
Après avoir eu à parler des conditions, dit “structures conditionnelles”, en Dart, nous voici pour une nouvelle leçon celle qui ne serait pas loin de la précédente les boucles, dit “structures itératives”.
Les boucles, comme dit, sont des structures qui permettent d’exécuter un bloc de code de manière répétée soit jusqu’à un nombre déterminé de fois soit jusqu’à ce qu’une condition donnée soit vérifiée.
Elles sont composées de 2 grandes parties :
- La déclaration de contrôle
- Le corps de la boucle
La valeur qui nous permettra de parcourir une boucle est dit index.
Dans ce cours, nous allons les classer à 4 catégories :
1. La Boucle for
Cette boucle est utilisée pour exécuter un bloc de code à un nombre déterminé de fois. D’où, elle est classée parmi les boucles dit “précises”, car on sait d’avance combien de fois elle répètera les instructions contenues dans la partie corps de la boucle.
Nous allons partir d’une valeur initiale à une valeur limite de fois.
La syntaxe de la partie déclaration de contrôle est composé de 3 grandes parties : une initialisation, une condition et une incrémentation ou un décrémentation.
//Exemple d'une boucle for
/*Notons que i est dit index, et il commence de 0 (partie initialisation)
puis se termine à 9 vu que la condition nous dit qu'il doit rester
inférieur à 10 (partie condition) et il s'incrémente à chaque itération-
chaque tour de la boucle-(partie incrémentation)*/
for (int i = 0; i < 10; i++) {
print("La $i fois que la boucle se répète.");
}2. Boucle for in
Cette boucle est utilisée pour itérer sur les éléments d’une collection (Notion que nous verrons dans un des chapitres qui viennent). Elle prend un élément qui serait comme référence à chaque élément de la collection (List, Map, …). D’où elle tourne au nombre des éléments de la collection dans laquelle elle puise sa référence.
La syntaxe de la partie déclaration de contrôle est composé simplement : d’une variable du type des éléments de la collection puis in et de la collection de référence.
//Déclaration de notre collection, ici une liste des alphabets
List alphabets = ["a", "b", "c"];
//La boucle ayant une référence alphabet de notre liste alphabets
for (String alphabet in alphabets) {
print(alphabet);
}3. Boucle while
Cette boucle est utilisée pour exécuter un bloc de code tant qu’une condition est vraie. Ce qui revient à dire qu’on n’a pas une idée fixe de combien de fois l’itération sera exécutée, d’où son classement parmi les boucles dit “indéterminée”.
Notons ici qu’il faut une instruction dans le bloc d’instructions permettant à la condition d’arrêt de la boucle d’être vérifiée (être vraie) après un moment, sinon la boucle ne s’arrêtera jamais jusqu’à ce que ta machine s’éteigne ou craque 🙃
//Exemple d'un algo avec la boucle while
int i = 0;
/*L'entrée de la boucle est conditionnée, ce qui veut dire que la boucle
tournera tant que la condition d'entrée n'est pas vérifiée, dans notre
cas tant que i sera inférieur à 10*/
while (i < 10) {
print("i est égal à $i");
/*Intruction permettant de vérifier la condition d'entrée,
ici chaque fois i s'incrémente pour finir par atteindre 10*/
i++;
}4. Boucle do while
Cette boucle est semblable à celle de while mais la différence est qu’elle exécute un bloc de code au moins une fois avant la condition d’arrêt, puis de manière répétée tant qu’une condition est vraie.
int i = 0;
/*L'entrée de la boucle n'est pas conditionnée, ce qui veut dire que
la boucle commence par exécuté une première fois le bloc de code de
l'itération, puis continue à tourner tant que la condition retrouvée
à la sortie de la boucle n'est pas vérifiée*/
do {
print("i est égal à $i");
//Instruction permettant d'arrêter la boucle
i++;
} while (i < 10);Avant de passer au point suivant, une question revient souvent dans la programmation, laquelle de ces boucles choisir pour telle ou telle autre tâche ? 🤷♀️
Nous allons donner quelques points sur lesquels se baser pour le choix d’une boucle.
D’abord commencer par analyser le problème donné et regarder si vous avez besoin d’un test (condition) avant d’exécuter la répétition (l’itération) d’un bloc d’instructions ou après avoir eu à l’exécuter au moins une fois.
a. Pour le pré-test (condition vérifiée avant d’entrée dans la boucle), utilisez la boucle for et while
b. Pour le post-test (condition vérifiée après avoir exécuté au moins une fois la boucle), utilisez la boucle do while
5. Les Instructions de contrôle de boucle
Ici, nous ne sommes pas dans une des catégories de boucles, mais nous parlerons sous ce point des instructions qui nous permettent de contrôler les boucles dans leur itération.
En Dart, nous en comptons 3 :
a. L’instruction break
Déjà rencontré précédemment dans la structure conditionnelle switch , ici aussi il joue le même rôle, celui de nous faire quitter de l’itération (les instructions) d’une boucle, autrement dit faire arrêter la boucle (comme veut dire ses sens “casser, rompre, arrêter, …”), et de passer à la suite du programme.
//Exemple d'une boucle for avec l'instruction break
//Ce code s'arrête ou on quitte l'itération dès que i sera égal à 5
for (int i = 0; i < 10; i++) {
if (i == 5) {
break;
}
print("i est égal à $i");
}b. L’instruction continue
L’instruction continue, quant à elle, est utilisée pour passer à l’itération suivante d’une boucle ou de sauter le reste du code dans l’itération en cours et de continuer avec l’itération suivante.
Exemple : Un programme qui affiche seulement les nombres impairs inférieurs à 10.
//Exemple d'une itération avec l'instruction continue
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue;
}
print("$i est impair.");
}Notons ici que le signe % est dit modulo, c’est une opération qui calcul la division et retient le reste de cette division.
C’est ainsi que notre condition dit que si le reste de la division entre l’index i et 2 est égale à 0 passer (continuer), parce que c’est un nombre pair, sinon afficher “$i est impair.”
c. Les “label”
Les labels sont des instructions appelé identifiants suivies par deux points (:), qui s’appliquent à une déclaration ou à un bloc de code, permettant de pointer à un endroit particulier une instruction ou un bloc d’instructions du programme.
Elles peuvent être utilisées avec break ou continue pour une grande précision sur le bloc d’instruction à quitter ou à continuer.
//Exemple d'un bloc de code contrôler par un label avec un break
maBoucleExterne:
for (int i = 0; i < 3; i++) {
//maBoucleInterne:
for (int j = 0; j < 3; j++){
print("$i $j");
if (i == 2 && j == 2) {
//Ce break permettrant d'arrêter directement la boucle externe
//Mais si il n'est pas là seule, la boucle interne sera arrêter
break maBoucleExterne;
}
}
}
//Exemple d'un bloc de code contrôler par un label avec un continue
maBoucleExterne:
for (int i = 0; i < 3; i++) {
//maBoucleInterne:
for (int j = 0; j < 3; j++){
print("$i $j");
if (i == 2 && j == 2) {
continue maBoucleExterne;
}
}
}
/*Vous pouvez joueur avec le label de la boucle externe
et interne pour voir le changement*/
6. Conclusion
Enfin, nous avons eu à parcourir un grand trajet avec cette notion, maintenant nos algorithmes peuvent déjà être résolus en Dart.
Sous ce point il a été question de savoir ce quoi une boucle, les types de boucles en Dart et les instructions de contrôles en Dart.
Merci encore d’être avec nous jusqu’à cette étape, on n’arrête pas avant de voir ce qui se cache réellement à la fin de ce long chemin !
Merci et au chapitre suivant !
Portez-vous bien et n’oubliez pas une chose : “Ne limitez pas vos rêves !”.
😉
