Boucles while en JavaScript : while, do...while, break

Quand tu ne sais pas combien d'itérations il te faut

La boucle for est parfaite quand tu connais le nombre de tours à l'avance — « fais ça 10 fois », « parcours chaque index de ce tableau ». La boucle while en JavaScript, elle, sert à l'autre cas de figure : continuer tant qu'une condition reste vraie. Tu ignores combien d'itérations ça va prendre, tu connais juste la condition qui te fera sortir.

La syntaxe du while en JavaScript est minimaliste :

JavaScript évalue la condition entre parenthèses. Si elle est truthy, le bloc s'exécute. Puis la condition est réévaluée, encore et encore, jusqu'à devenir falsy. Oubliez le count++ et la condition ne bougera jamais — bienvenue dans la boucle infinie.

Le modèle mental : vérifier, exécuter, recommencer

Pour qu'une boucle while en JavaScript ait du sens, il faut réunir trois conditions :

1. Une variable dont dépend la condition.
2. Un moyen, dans le corps de la boucle, de faire évoluer cette variable.
3. Une condition qui finit par devenir fausse.

S'il en manque une seule, gros souci. Le bug classique, c'est d'oublier le point 2 :

let count = 0;

while (count < 5) {
    console.log(count);
    // oubli d'incrémenter count — boucle infinie
}

Et c'est parti pour une boucle qui tourne jusqu'à ce que tu tues le processus. Sur un serveur, ça peut faire très mal. Pose-toi toujours la question : qu'est-ce qui, dans le corps de la boucle, va rendre la condition fausse ?

Un cas concret : quand on ne connaît pas le nombre d'itérations

C'est là que while prend le dessus sur for. Tu consommes des éléments venus d'on ne sait où, et tu ignores combien il y en a tant que la source n'est pas vidée :

shift() retire le premier élément du tableau et le renvoie. La boucle tourne tant que la file contient quelque chose, puis s'arrête toute seule quand elle est vide. On pourrait écrire ça avec un for, mais on irait à contre-courant du problème — while colle parfaitement à l'intention.

do...while en JavaScript : on exécute d'abord, on vérifie après

Le do...while inverse l'ordre des opérations : on exécute le corps, puis on teste la condition. Résultat : au moins un tour de boucle garanti :

Le corps s'exécute toujours au moins une fois, même si la condition est fausse dès le départ. À comparer avec le while classique, où une condition fausse signifie zéro itération.

Le cas typique : demander une saisie à l'utilisateur, valider la réponse, et redemander si elle n'est pas valable. Comme on veut forcément poser la question au moins une fois, do...while tombe à pic.

Attention au point-virgule après la ) finale : contrairement à while et for, do...while en exige un.

break : sortir d'une boucle while en JavaScript

break fait sortir immédiatement de la boucle englobante. C'est le moyen d'arrêter la boucle quand la condition naturelle ne suffit pas à exprimer ce qu'on veut :

Une fois que break s'exécute, plus rien ne tourne dans la boucle — ni le reste du corps, ni une nouvelle vérification de la condition. Tu es sorti, point.

while (true) avec break

Quand la condition d'arrêt est plus simple à exprimer dans le corps de la boucle que dans son en-tête, inverse la logique : boucle à l'infini et sors avec break dès que c'est terminé.

Deux sorties possibles : la réussite, ou un garde-fou. Et ce garde-fou, c'est loin d'être un détail. Un while (true) sans chemin de break garanti, c'est la boucle infinie assurée.

continue : passer directement à l'itération suivante

continue renvoie directement au test de la condition, en sautant tout ce qui reste du corps de l'itération en cours :

Un piège classique : si l'instruction qui fait avancer ta boucle se trouve après le continue, félicitations, tu viens de créer une boucle infinie. Dans l'exemple ci-dessus, n++ est placé avant le continue, donc tout va bien. Mets-le après et n restera bloqué sur un nombre pair jusqu'à la fin des temps.

Boucle while ou for en JavaScript : laquelle choisir ?

Une règle mécanique pour s'y retrouver :

• Compter ou parcourir une plage connue → for. Avec for (let i = 0; i < arr.length; i++), l'initialisation du compteur, la condition et l'incrément tiennent sur une seule ligne.
• Parcourir une collection → for...of. Bien plus propre que de gérer un index à la main.
• Boucler jusqu'à ce qu'un état change → while. Idéal pour traiter une file d'attente, faire du polling, consommer un flux ou réessayer jusqu'au succès.
• Exécuter le corps au moins une fois → do...while.

En théorie, elles sont interchangeables : n'importe quel for peut se réécrire en while et inversement. Mais choisir celle qui colle à la forme du problème rend le code auto-documenté.

Boucle infinie en JavaScript : la règle d'or

Chaque boucle while doit répondre clairement à cette question : qu'est-ce qui l'arrête ?

Soit la condition de l'en-tête finira par devenir fausse, soit il y a un break dont tu es sûr qu'il sera atteint. Si tu ne peux pointer ni l'un ni l'autre, c'est que ta boucle n'est pas encore terminée.

// Mauvais : la condition ne change jamais
let ready = false;
while (!ready) {
    console.log("en attente...");
    // rien ici ne bascule `ready`
}

// Bon : le corps influence la condition
let ready = false;
let checks = 0;
while (!ready) {
    checks++;
    if (checks >= 3) ready = true;
}

Dans le navigateur, une boucle infinie fige l'onglet. Sous Node, elle sature un cœur CPU jusqu'à ce que vous tuiez le processus. Autant les repérer avant la mise en prod.

La suite : for...of et for...in

while est parfait quand on boucle « jusqu'à ce que quelque chose change ». Mais pour parcourir des tableaux, des chaînes ou des objets élément par élément, JavaScript propose deux autres formes de boucles conçues précisément pour ça : for...of et for...in, qu'on voit juste après.