continue en JavaScript : passer au tour suivant sans quitter la boucle

Dans un parcours, certains éléments ne concernent pas le traitement : une facture déjà réglée, une ligne vide, un utilisateur désinscrit. Le réflexe habituel consiste à envelopper tout le corps de la boucle dans une condition.

continue propose l'inverse : écarter le cas indésirable en une ligne, en haut, et laisser le traitement principal à plat.

Définition

continue abandonne le tour de boucle en cours et passe immédiatement au suivant. Le parcours n'est pas interrompu, contrairement à ce que fait break : seules les lignes situées après le mot-clé sont sautées, et seulement pour cet élément.

const factures = [{ montant: 0 }, { montant: 120 }, { montant: 80 }];
let relances = 0;

for (const facture of factures) {
  if (facture.montant === 0) continue;   // rien à relancer sur celle-ci
  relances++;
}

console.log(relances);   // 2

Le gain est un niveau d'indentation en moins, et une lecture qui suit l'ordre du raisonnement : d'abord ce qu'on écarte, ensuite ce qu'on fait. Sur une boucle qui écarte trois cas, la version imbriquée demande trois accolades de plus.

Ce qui le distingue de break

La question à se poser tient en une phrase : les éléments restants ont-ils encore un intérêt ? S'ils en ont un, c'est continue ; sinon, c'est break.

Le piège du compteur non incrémenté

Dans une boucle while, continue saute tout ce qui suit, y compris la ligne qui fait avancer le compteur. La condition reste alors vraie indéfiniment et le programme se fige, sans erreur ni message.

let i = 0;

while (i < 3) {
  if (i === 1) continue;   // à ne pas exécuter : i ne bouge plus, la boucle ne s'arrête jamais
  i++;
}

Une boucle for n'a pas ce défaut : l'expression de mise à jour est écrite dans l'en-tête et s'exécute même quand un continue a sauté le corps.

for (let i = 0; i < 3; i++) {
  if (i === 1) continue;   // l'incrément de l'en-tête a quand même lieu
  console.log(i);          // 0 puis 2
}

Questions fréquentes

Quand l'écart repose sur un seul critère et que le traitement suit, Array.filter() dit l'intention plus clairement : la liste est réduite d'abord, parcourue ensuite. continue garde l'avantage quand plusieurs conditions d'exclusion s'accumulent, ou quand l'écart doit être journalisé au passage.

Le mot-clé lui-même est refusé, puisque le corps passé à Array.forEach() est une fonction et non un bloc de boucle. Un return écrit à sa place produit le même effet : il termine l'appel pour l'élément en cours et le parcours reprend. Ce qui reste impossible dans forEach, c'est l'équivalent de break.

Oui, en nommant la boucle extérieure et en écrivant continue suivi de ce nom. Le tour en cours de la boucle intérieure est abandonné, et c'est la boucle extérieure qui avance d'un cran. La construction est correcte mais rare : quand elle devient nécessaire, extraire la boucle intérieure dans une function rend souvent le même service plus lisiblement.