Règle
Ne utiliser break dans boucles boucles.
Break statements en profondément imbriquées boucles font
contrôle flux difficile à suivre sans documentation documentation.

Langues prises en charge : 45+

Introduction

Les instructions `break` dans les boucles imbriquées créent une ambiguïté quant à la boucle qui est quittée et dans quelles conditions. Quand un/une Break apparaît profondément à l'intérieur de plusieurs boucles, les lecteurs doivent remonter avec attention pour déterminer quelle boucle elle termine et si les boucles externes continuent de s'exécuter. Cette surcharge cognitive augmente à chaque niveau d'imbrication, rendant le code difficile à comprendre et à maintenir.

Pourquoi c'est important

Maintenabilité du code : Les instructions `break` dans les boucles imbriquées obscurcissent le flux de contrôle. Les futurs mainteneurs doivent suivre mentalement quelle boucle est interrompue et ce qu'il advient des boucles externes. Cela devient source d'erreurs lors de la modification de la logique des boucles ou de l'ajout de nouvelles conditions.

Complexité du débogage : Lors du débogage de boucles imbriquées avec des breaks, la définition de points d'arrêt et le pas à pas dans le code nécessitent de comprendre des chemins de sortie complexes. Un break dans une boucle interne pourrait empêcher l'exécution d'une logique de nettoyage ou de validation importante dans les boucles externes.

Exemples de code

❌ Non conforme :

function findUser(users, id) {
  let found = null;
  for (let i = 0; i < users.length; i++) {
    if (users[i].id === id) {
      found = users[i];
      break; // break is okay, but this pattern is verbose
    }
  }
  return found;
}

Pourquoi c'est incorrect : Le Break une instruction nécessite l'introduction d'une variable temporaire (Trouvé) pour stocker le résultat, puis le retourner après la boucle. Ce modèle verbeux ajoute une complexité inutile et rend le code plus difficile à suivre par rapport aux retours directs ou aux méthodes de tableau.

✅ Conforme :

function findUser(users, id) {
  return users.find(user => user.id === id);
}

OR

function findUser(users, id) {
  for (let i = 0; i < users.length; i++) {
    if (users[i].id === id) {
      return users[i];
    }
  }
  return null;
}

Pourquoi c'est important : L'option 1 utilise .find() qui est concis et exprime clairement l'intention. L'option 2 utilise retour pour quitter immédiatement lorsque l'utilisateur est trouvé, éliminant ainsi le besoin de variables temporaires et Break instructions. Les deux approches sont plus claires et plus maintenables que le pattern `break`.

Conclusion

Extrayez la logique des boucles imbriquées dans des fonctions là où retour sort clairement de toutes les boucles. Utilisez des méthodes de tableau comme find(), some(), ou every() pour remplacer les boucles internes lorsque c'est possible. Si les boucles imbriquées sont inévitables, utilisez des `break` étiquetés ou des drapeaux pour rendre les conditions de sortie explicites.