Aller au contenu
Encyclopédie informatique Édition 2026

Conditions et boucles

Partie 3 sur 4

Niveau de lecture :

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.

QUATRE BOUCLES, QUATRE USAGES for nombre de tours connu à l’avance for (i=1; i<=10; i++) : 10 tours while on teste avant chaque tour peut ne jamais s’exécuter do … while on teste après chaque tour au moins un tour garanti for … in / foreach parcourir chaque élément plus sûr : pas de compteur à gérer continue / break sauter un tour / quitter la boucle toujours avec une condition Attention à la borne : i<10 fait 10 tours (0 à 9), i<=10 en fait 11 (0 à 10).
Figure 3. Les boucles les plus courantes et leur usage typique. Attention à la borne : 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 :

Tableau 1. Combien de tours fait chaque boucle ?
BoucleValeurs de iNombre de tours
for (i = 0; i < 10; i++)0 à 910
for (i = 0; i <= 10; i++)0 à 1011
for (i = 1; i < 10; i++)1 à 99
for (i = 1; i <= 10; i++)1 à 1010

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.

Tableau 2. Structures de contrôle dans cinq langages (et trois autres pour comparer).
LangageSi… sinonChoix multipleParticularités
Cif / else if / elseswitch avec breakvrai = non nul ; déclaration dans le for depuis 1999
C++comme en Ccomme en Cdéclaration dans le for ; vrai booléen bool
Javacomme en Cswitch classique, puis à flèchela condition doit être un booléen, pas un nombre
JavaScriptcomme en Cswitch avec break== contre === ; valeurs truthy et falsy ; for … of
PHPif / elseif / elseswitch avec breakvariables préfixées par $ ; foreach ; exit
Pythonif / elif / elsematch (3.10)l’indentation fait la syntaxe ; pas d’accolades
Rustif est une expressionmatch exhaustifcondition strictement booléenne ; loop pour la boucle sans fin
Goif sans parenthèsesswitch sans passage au suivantun 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.