Conditions et boucles

Objectifs

À la fin de cette leçon, vous saurez :

• exécuter du code conditionnellement avec if/else if/else, dans le bon ordre ;
• écrire des conditions composées lisibles, et éviter le piège des valeurs truthy/falsy ;
• répéter avec for, while et for...of, en sachant lequel choisir ;
• interrompre une boucle (break, continue) et éviter les boucles infinies.

🔗 Pour vous rafraîchir la mémoire : variables et types primitifs

Le programme qui décide : if / else if / else

Jusqu'ici vos programmes exécutaient chaque ligne, de haut en bas, sans réfléchir. La condition introduit la première vraie décision :

const note = 14;

if (note >= 16) {
  console.log("Excellent");
} else if (note >= 12) {
  console.log("Bien");
} else {
  console.log("À retravailler");
}

$ node notes.js
Bien

Mécanique exacte : JavaScript évalue note >= 16 → false. Branche sautée. Évalue note >= 12 → true : le bloc s'exécute, et tout le reste est ignoré — même si d'autres conditions plus bas seraient aussi vraies. C'est un point capital : une seule branche s'exécute jamais, la première dont la condition est vraie.

L'ordre des conditions est donc porteur de sens. Inversez-les et observez le bug :

// BUG : l'ordre rend les bonnes notes inatteignables
if (note >= 12) {
  console.log("Bien");          // une note de 18 tombe ici !
} else if (note >= 16) {
  console.log("Excellent");     // ...jamais atteint
}

Règle pratique : ordonnez du plus restrictif au plus général. Et rappelez-vous que la condition entre parenthèses est une expression booléenne (évaluée à true ou false) — vous savez déjà la composer avec && et || depuis la leçon précédente :

if (age >= 18 && aUnPermis) {
  console.log("Vous pouvez conduire");
}

Le else final est le plan B universel : il couvre « tous les autres cas ». Grâce à lui, la logique est exhaustive : toute valeur possible aboutit quelque part.

Truthy et falsy : quand une valeur fait office de condition

JavaScript accepte n'importe quelle valeur dans une condition, pas seulement des booléens :

if ("bonjour") { console.log("texte non vide → traité comme vrai"); }
if (0)         { console.log("jamais affiché"); }   // 0 → faux
if ("")        { console.log("jamais affiché"); }   // texte vide → faux
if ([])        { console.log("tableau vide → vrai !"); }

La liste complète des valeurs falsy (traitées comme fausses) tient en six lignes :

false    0    ""    null    undefined    NaN

Tout le reste est truthy — y compris "0" (texte), [] (tableau vide) et {} (objet vide). Ces deux derniers surprennent tout le monde au début.

Conseil de style : cette souplesse permet des raccourcis (if (nom) pour « nom a une valeur »), mais elle est piégeuse autour de zéro : if (quantite) ne distingue pas « absent » et « zéro ». Quand le sens compte, soyez explicite : if (quantite > 0), ou mieux encore if (quantite !== undefined). Les conditions explicites vieillissent mieux.

Répéter : for, la boucle comptée

for (let i = 1; i <= 5; i++) {
  console.log(`tour numéro ${i}`);
}

tour numéro 1
tour numéro 2
tour numéro 3
tour numéro 4
tour numéro 5

Les trois parties entre parenthèses, séparées par des points-virgules, ont chacune un rôle précis :

Partie	Code	Moment d'exécution
initialisation	let i = 1	une seule fois, avant tout
condition	i <= 5	avant chaque tour ; fausse → sortie
pas	i++	après chaque tour

Déroulons complètement, car comprendre ce déroulement vaut dix exercices :

init      : i = 1
condition : 1 <= 5 → vrai   → corps (« tour numéro 1 ») → pas : i = 2
condition : 2 <= 5 → vrai   → corps (« tour numéro 2 ») → pas : i = 3
...
condition : 5 <= 5 → vrai   → corps (« tour numéro 5 ») → pas : i = 6
condition : 6 <= 5 → FAUX   → boucle terminée, programme continue

La variable i n'existe que dans la boucle (déclarée par let). Convention quasi universelle : i, puis j pour une seconde boucle imbriquée.

Cas d'usage type : compter, parcourir par index, répéter N fois. Quand le nombre de tours se connaît d'avance, for est l'outil.

Répéter : while, la boucle conditionnelle

let nombre = 3;
while (nombre > 0) {
  console.log(nombre);
  nombre--;              // indispensable !
}
console.log("Décollage");

3
2
1
Décollage

while vérifie sa condition avant chaque tour ; si elle est fausse dès le départ, le corps ne s'exécute jamais. Cas d'usage : on ne sait pas combien de tours seront nécessaires — « tant que l'utilisateur n'a pas trouvé », « tant qu'il reste des données ».

⚠️ La boucle infinie, premier grand accident du débutant : si le corps oublie de faire évoluer la condition (nombre-- oublié), la condition reste vraie pour toujours. Le programme ne répond plus ; votre terminal semble figé. Remède : Ctrl+C interrompt le processus node. Testez-le volontairement une fois pour connaître la sensation :

while (true) {
  // Ctrl+C pour sortir — ne laissez pas tourner longtemps
}

Règle d'or : toute boucle doit contenir, quelque part, un geste qui la rapproche de sa sortie.

break et continue : piloter finement

Deux mots-clés donnent un contrôle supplémentaire :

const nombres = [4, 8, 15, 16, 23, 42];

for (const n of nombres) {
  if (n === 15) {
    break;               // quitte TOUTE la boucle immédiatement
  }
  console.log(n);
}
// affiche 4, 8 — puis stop dès le 15

for (const n of nombres) {
  if (n % 2 === 0) {
    continue;            // saute ce tour-ci, continue la boucle
  }
  console.log(`${n} est impair`);
}
// affiche seulement 15 et 23

break sert typiquement à s'arrêter dès qu'on a trouvé ; continue à filtrer pendant le parcours.

Parcourir une collection : for...of

C'est la boucle que vous utiliserez le plus souvent, car les programmes réels manipulent surtout des collections :

const fruits = ["pomme", "banane", "kiwi"];

for (const fruit of fruits) {
  console.log(`J'aime les ${fruit}s`);
}

J'aime les pommes
J'aime les bananes
J'aime les kiwis

Lecture : « pour chaque élément de fruits, appelons-le fruit, fais ceci ». Pas d'index à gérer, pas de risque de déborder : la boucle s'arrête seule à la fin du tableau.

Si l'index compte aussi (numéroter les éléments, accéder à la position), revenez au for classique :

for (let i = 0; i < fruits.length; i++) {
  console.log(`${i} : ${fruits[i]}`);
}
// 0 : pomme
// 1 : banane
// 2 : kiwi

Notez < et non <= : les index vont de 0 à length - 1. Avec <=, le dernier tour lirait fruits[3] → undefined.

Choisir son outil

Situation	Outil
Exécuter un bloc selon une situation	if / else if / else
Répéter un nombre de tours connu	for
Répéter tant qu'une condition tient	while
Parcourir tous les éléments d'une collection	for...of
Sortir en cours de route / sauter un tour	break / continue

Exercice

1. Pair ou impair : pour nombre = 42, affichez « pair » ou « impair ».
2. Comptez de 1 à 10 avec for, puis refaites avec while.
3. Table de 7 : affichez 7 × i = résultat pour i de 1 à 10.
4. Numérotez : avec ["un", "deux", "trois"], affichez chaque élément précédé de son index.
5. Deviner : secret = 7 et essai = 10 ; affichez « trop grand », « trop petit » ou « trouvé ». Testez les trois cas en changeant essai.
6. FizzBuzz léger : pour i de 1 à 15, affichez « fizz » si i est divisible par 3, sinon le nombre.
7. Écrivez une boucle volontairement infinie, lancez-la, sortez avec Ctrl+C. Notez ce que donne echo $? juste après.
8. Somme jusqu'au seuil : avec while, ajoutez les nombres 1, 2, 3... jusqu'à dépasser 100, puis affichez le dernier nombre ajouté et la somme totale.

Résumé

• Une seule branche d'un if s'exécute : la première vraie — donc l'ordre des conditions compte.
• Six valeurs falsy (false 0 "" null undefined NaN), tout le reste est truthy ; préférez les conditions explicites.
• for compte, while attend une condition, for...of parcourt une collection ; break/continue pilotent en cours de route.
• Toute boucle doit progresser vers sa sortie — sinon Ctrl+C.

const nombre = 42;
if (nombre % 2 === 0) {
  console.log("pair");
} else {
  console.log("impair");
}

for (let i = 1; i <= 10; i++) console.log(i);

let j = 1;
while (j <= 10) { console.log(j); j++; }

for (let i = 1; i <= 10; i++) console.log(`7 × ${i} = ${7 * i}`);

const mots = ["un", "deux", "trois"];
for (let i = 0; i < mots.length; i++) {
  console.log(`${i} : ${mots[i]}`);
}

const secret = 7;
let essai = 10;

if (essai > secret)       console.log("trop grand");
else if (essai < secret)  console.log("trop petit");
else                      console.log("trouvé");

for (let i = 1; i <= 15; i++) {
  if (i % 3 === 0) {
    console.log("fizz");
  } else {
    console.log(i);
  }
}

^C
$ echo $?
130

let somme = 0;
let n = 0;

while (somme <= 100) {
  n++;
  somme += n;
}

console.log(`dernier nombre ajouté : ${n}`);   // 14
console.log(`somme totale : ${somme}`);        // 105