Conditions et boucles
Partie 3 sur 4
6Répéter : les boucles
Les boucles sont des structures qui permettent d’exécuter plusieurs fois la même série d’instructions, jusqu’à ce qu’une condition ne soit plus réalisée. On les appelle parfois instructions répétitives ou itérations (une itération est un tour de boucle). La façon la plus commune de faire une boucle est de créer un compteur, c’est-à-dire une variable qui s’incrémente (qui augmente de 1 à chaque tour) et de faire arrêter la boucle quand le compteur dépasse une certaine valeur.
i<10 fait 10 tours, i<=10 en fait 11 si l’on part de 0.6.1La boucle for
L’instruction for exécute plusieurs fois la même série d’instructions : c’est la boucle à compteur. Dans sa syntaxe, on précise trois choses, séparées par des points-virgules : le nom de la variable qui sert de compteur (avec sa valeur de départ), la condition pour laquelle la boucle continue (basiquement, le compteur n’a pas dépassé une limite), et l’instruction qui modifie le compteur (l’incrémente ou le décrémente).
for (compteur; condition; modification du compteur) {
liste d'instructions;
}
Voici un exemple en C :
for (i = 1; i < 6; i++) {
printf("%d", i);
}
Cette boucle affiche 5 fois la valeur de i, c’est-à-dire 1, 2, 3, 4, 5. Elle commence à i = 1, vérifie que i est bien inférieur à 6, exécute le bloc, incrémente, et recommence, jusqu’à atteindre i = 6, valeur pour laquelle la condition n’est plus réalisée : la boucle s’interrompt et le programme continue son cours. En PHP, le même exemple s’écrit avec le signe dollar devant les variables : for ($i = 1; $i < 6; $i++) { echo "$i<br>"; } (le <br> force un retour à la ligne dans une page web).
Détail pratique signalé dans les chapitres sur C++, Java et PHP : ces langages autorisent la déclaration de la variable de boucle dans l’instruction for elle-même, par exemple for (int i = 0; i < 10; i++) en C++ et en Java, ou for ($i = 0; $i < 10; $i++) en PHP. Cette variable n’existe alors qu’à l’intérieur de la boucle, ce qui est plus propre. (En C, cette écriture est permise depuis la norme de 1999.)
6.2Bien compter les tours
Attention : il faut bien compter le nombre de fois que l’on veut faire exécuter la boucle. Un tableau suffit à fixer les idées :
| Boucle | Valeurs de i | Nombre de tours |
|---|---|---|
for (i = 0; i < 10; i++) | 0 à 9 | 10 |
for (i = 0; i <= 10; i++) | 0 à 10 | 11 |
for (i = 1; i < 10; i++) | 1 à 9 | 9 |
for (i = 1; i <= 10; i++) | 1 à 10 | 10 |
L’erreur d’un tour en trop ou en moins est si fréquente qu’elle a un nom : l’erreur d’un (off-by-one error). Une règle de prudence : par convention, on compte à partir de 0 avec la borne exclue (i < n), et l’on se demande toujours « que se passe-t-il au premier tour ? au dernier ? ».
6.3Toujours une condition de sortie
Deux conseils sont à garder en mémoire. Premier conseil : il faudra toujours vérifier que la boucle a bien une condition de sortie, c’est-à-dire que le compteur s’incrémente correctement, dans le sens qui rapproche de la limite. Second conseil : une instruction d’affichage dans la boucle (printf en C, echo en PHP) est un bon moyen de vérifier la valeur du compteur pas à pas, en l’affichant. Cette méthode de débogage, qui consiste à faire parler le programme, reste la plus simple (voir le langage C pour les premiers programmes).
6.4La boucle while
L’instruction while (« tant que ») est un autre moyen d’exécuter plusieurs fois la même série d’instructions. Elle exécute la liste d’instructions tant que la condition est réalisée. La condition est testée avant chaque tour : si elle est fausse d’entrée, la boucle ne s’exécute jamais.
while (condition) {
liste d'instructions;
}
Elle convient quand on ne sait pas à l’avance combien de tours seront nécessaires : lire un fichier jusqu’à la fin, attendre qu’un utilisateur donne une réponse valide, chercher une valeur.
int essais = 0;
while (essais < 3 && !motDePasseCorrect) {
demanderLeMotDePasse();
essais++;
}
6.5Le danger : la boucle infinie
La condition de sortie pouvant être n’importe quelle expression, les risques de boucle infinie sont grands : une boucle dont la condition est toujours vraie risque de provoquer un plantage du programme en cours d’exécution. L’exemple type : oublier d’incrémenter le compteur.
int i = 0;
while (i < 10) {
printf("%d\n", i);
/* oubli : i++ ; la condition reste vraie à jamais */
}
Pour interrompre un programme qui tourne sans fin, on utilise le raccourci Ctrl+C dans le terminal. Certaines boucles infinies sont volontaires (un serveur qui attend des connexions écrit while (true) et ne s’arrête que sur ordre) ; la différence est qu’elles contiennent alors un moyen de sortie par break ou qu’elles sont conçues pour ne jamais finir.
6.6do … while : au moins un tour
Une variante, présente dans tous ces langages, teste la condition après chaque tour : do { … } while (condition);. Le bloc s’exécute donc au moins une fois. C’est pratique pour redemander une saisie tant qu’elle est invalide : on doit bien demander une première fois.
do {
reponse = demanderUnNombre();
} while (reponse < 1 || reponse > 10);
6.7Parcourir une collection : for … in, foreach
Quand on veut traiter chaque élément d’une liste ou d’un tableau, le compteur est un détour inutile, source d’erreurs d’un tour. Les langages modernes offrent la boucle « pour chaque » : for (const x of liste) en JavaScript, for x in liste: en Python, foreach ($liste as $x) en PHP, for (String s : liste) en Java, for x in &liste en Rust. Elle est plus courte, plus lisible et plus sûre : on ne peut plus dépasser la fin du tableau. C’est la forme à préférer chaque fois que le numéro de l’élément n’est pas nécessaire.
Pour s’exercer
Exercice 2 : combien de tours ?
Combien de fois chaque boucle s’exécute-t-elle ? for (i = 2; i < 8; i++) ; for (i = 2; i <= 8; i++) ; for (i = 0; i < 0; i++) ; for (i = 10; i > 0; i--).
Voir la réponse
6 tours (i vaut 2, 3, 4, 5, 6, 7) ; 7 tours (de 2 à 8) ; 0 tour (la condition est fausse dès le départ) ; 10 tours (i vaut 10, 9, …, 1). Un tableau minuscule, ou le calcul « borne haute moins borne basse » (en ajoutant 1 si la borne haute est incluse), évite l’erreur d’un tour.
Exercice 3 : le break oublié
Que s’affiche-t-il si jour vaut 2 ? switch (jour) { case 1: printf("A"); case 2: printf("B"); case 3: printf("C"); break; default: printf("D"); }
Voir la réponse
« BC ». Le cas 2 est sélectionné, « B » s’affiche ; comme il n’y a pas de break, l’exécution tombe dans le cas 3, qui affiche « C », puis le break sort du switch. Avec un break après chaque affichage, on n’aurait eu que « B ».
Exercice 4 : repérer la boucle infinie
Pourquoi ce code ne s’arrête-t-il jamais ? Corrigez-le. int n = 10; while (n != 0) { n = n - 3; }
Voir la réponse
n prend les valeurs 10, 7, 4, 1, -2, -5… et ne passe jamais exactement par 0 : la condition « n est différent de 0 » reste vraie. Il aurait fallu tester n > 0, qui s’arrête dès que n devient négatif ou nul. La leçon : préférer un test d’ordre (>, <) à un test d’égalité exacte pour arrêter une boucle.
Exercice 5 : continue ou break ?
On parcourt les notes d’une classe. Pour calculer la moyenne, on veut ignorer les notes absentes (codées -1). Pour chercher la première note supérieure à 18, on veut s’arrêter dès qu’on la trouve. Quelle instruction pour chaque cas ?
Voir la réponse
Pour ignorer les notes absentes : if (note == -1) continue; (on saute ce tour et on passe à la note suivante). Pour la première note supérieure à 18 : if (note > 18) { trouve = note; break; } (inutile de lire le reste, on quitte la boucle).
Exercice 6 : réécrire proprement
Réécrivez avec des clauses de garde, sans imbrication : if (u != null) { if (u.estActif()) { if (u.aLeDroit("lire")) { lire(); } } }
Voir la réponse
if (u == null) { return; }
if (!u.estActif()) { return; }
if (!u.aLeDroit("lire")) { return; }
lire();
Même comportement, un seul niveau d’indentation. On notera aussi que chaque ligne traite un cas de refus : la logique est « fermée par défaut », on ne lit que si tout est en règle.
Exercice 7 : un petit programme complet
Décrivez en français, puis écrivez en pseudo-code, un programme qui demande un nombre entre 1 et 10 tant que la réponse est invalide (3 essais au plus), puis affiche « Bravo » si le nombre est 7 et « Raté » sinon.
Voir la réponse
essais = 0
valide = faux
tant que (essais < 3 et non valide) {
n = demander()
essais = essais + 1
si (n >= 1 et n <= 10) { valide = vrai }
}
si (non valide) { afficher("Trop d'essais") }
sinon si (n == 7) { afficher("Bravo") }
sinon { afficher("Raté") }
On trouve ici une boucle bornée (3 essais) avec une condition à deux parties, et une chaîne si…sinon qui traite d’abord le cas d’échec. C’est la structure d’un grand nombre de programmes réels.
7Sauter un tour, quitter la boucle : continue et break
7.1continue : le saut inconditionnel
Il peut être nécessaire de faire sauter à la boucle une ou plusieurs valeurs sans pour autant mettre fin à celle-ci. L’instruction qui le permet est continue; (elle ne s’emploie qu’à l’intérieur d’une boucle). On l’associe généralement à une structure conditionnelle : sans cela, les lignes situées entre cette instruction et la fin de la boucle seraient inutiles, puisque jamais exécutées.
Un exemple : imaginons que l’on veuille afficher, pour x allant de 1 à 10, la valeur de 1/(x-7). Il est évident que pour x = 7 il y aura une erreur, car on diviserait par zéro. Grâce à continue, il est possible de traiter cette valeur à part, puis de continuer la boucle :
for (x = 1; x <= 10; x++) {
if (x == 7) {
printf("division par 0 évitée\n");
continue;
}
printf("1/%d\n", x - 7);
}
Quand x vaut 7, le message s’affiche, puis continue renvoie directement au tour suivant (x = 8) sans exécuter le printf final.
7.2break : arrêter la boucle
Dans l’exemple précédent, on savait à quel moment le dénominateur s’annule. Mais pour des équations plus compliquées, on ne le sait pas toujours. Il est alors possible de faire arrêter la boucle en cas d’annulation du dénominateur, pour éviter la division par zéro. L’instruction qui le permet est break;, la même que dans le switch : elle sort de la boucle courante. Comme continue, on l’associe à une condition, sans laquelle la boucle ne ferait jamais plus d’un tour.
for (x = 1; x <= 10; x++) {
a = x - 7;
if (a == 0) {
printf("division par 0\n");
break;
}
printf("1/%d\n", a);
}
Ici, la boucle s’interrompt complètement quand x atteint 7 : les valeurs 8, 9 et 10 ne sont pas traitées. À vous de choisir entre continue (ignorer cette valeur, poursuivre) et break (tout arrêter), selon ce que le problème demande. Une règle de lecture : continue dit « passons au suivant », break dit « j’ai fini, ou je ne peux pas continuer ».
7.3Arrêter tout le programme
Reste un cas plus radical, fréquent en PHP : la commande exit, qui permet d’interrompre totalement l’interprétation du script. Le serveur n’envoie plus d’informations au navigateur : le script est figé dans son état actuel. Cette instruction est particulièrement utile lors de l’apparition d’une erreur. Toutes les familles de langages ont l’équivalent (exit() en C, System.exit() en Java, process.exit() en Node.js, l’environnement qui exécute JavaScript hors du navigateur). Aujourd’hui, on préfère traiter les erreurs de façon plus fine, par la gestion des exceptions (voir la gestion des erreurs et des exceptions), qui permet de nettoyer avant de s’arrêter.
8Les cinq langages côte à côte
Ces langages se ressemblent, à quelques détails près : c’est la preuve qu’ils ont une même racine, le C (voir les langages de programmation). Voici les principales différences.
| Langage | Si… sinon | Choix multiple | Particularités |
|---|---|---|---|
| C | if / else if / else | switch avec break | vrai = non nul ; déclaration dans le for depuis 1999 |
| C++ | comme en C | comme en C | déclaration dans le for ; vrai booléen bool |
| Java | comme en C | switch classique, puis à flèche | la condition doit être un booléen, pas un nombre |
| JavaScript | comme en C | switch avec break | == contre === ; valeurs truthy et falsy ; for … of |
| PHP | if / elseif / else | switch avec break | variables préfixées par $ ; foreach ; exit |
| Python | if / elif / else | match (3.10) | l’indentation fait la syntaxe ; pas d’accolades |
| Rust | if est une expression | match exhaustif | condition strictement booléenne ; loop pour la boucle sans fin |
| Go | if sans parenthèses | switch sans passage au suivant | un seul mot-clé de boucle : for |
L’exemple ci-dessous montre le même test dans trois langages, pour constater que les idées sont identiques et que seule l’écriture change.
/* C, C++, Java, JavaScript, PHP (à la variable près) */
if (age >= 18) { statut = "majeur"; } else { statut = "mineur"; }
# Python
if age >= 18:
statut = "majeur"
else:
statut = "mineur"
// Rust
let statut = if age >= 18 { "majeur" } else { "mineur" };
Pour approfondir un langage en particulier, voir le langage C, Python, Rust, Go, Kotlin, Swift, TypeScript et JavaScript.