Comment briser les boucles JavaScript et pourquoi vous pourriez en avoir besoin

Table des matières

Points Clés à Retenir

Les structures de contrôle itératives, ou boucles, sont des outils fondamentaux en JavaScript pour l’exécution répétée de portions de code. La maîtrise de leur syntaxe et de leurs particularités est primordiale.
L’instruction `break` offre la possibilité d’interrompre prématurément une boucle, contribuant ainsi à une exécution plus efficace du programme.
Savoir sortir d’une boucle peut significativement améliorer la performance de votre code, en évitant des itérations superflues et en facilitant la gestion des erreurs.

Les boucles JavaScript permettent de répéter des actions, mais il est parfois nécessaire de les interrompre pour gérer des situations spécifiques. C’est là que l’instruction `break` prend tout son sens. Examinons ensemble le fonctionnement de cette instruction et son utilité.

Maîtriser les Boucles JavaScript

Les boucles JavaScript simplifient la répétition de code, optimisant ainsi vos programmes et réduisant les répétitions inutiles. Elles sont un élément incontournable de la programmation et sont présentes dans la quasi-totalité des applications. Si vous débutez en JavaScript, il est donc essentiel de bien comprendre leur fonctionnement.

Les principaux types de boucles que tout développeur JavaScript doit connaître sont :

La boucle `for`
La boucle `while`
La boucle `do…while`
La boucle `for…in`
La boucle `for…of`

Chacune de ces boucles sert à l’itération, mais présente des subtilités qui les rendent plus ou moins adaptées selon les contextes. Voici un aperçu de la syntaxe de chaque type de boucle :

Type de Boucle	Syntaxe	Description
for	for (initialisation; condition; incrémentation) { // Instructions }	Exécute un bloc de code de façon répétée tant qu’une condition spécifiée (condition) est vérifiée. L’expression d’initialisation (initialisation) s’exécute une seule fois au début, tandis que l’expression d’incrémentation (incrémentation) est exécutée à chaque fin d’itération.
while	while (condition) { // Instructions }	Exécute un bloc de code tant que la condition spécifiée demeure vraie.
do…while	do { // Instructions } while (condition);	Exécute un bloc de code au moins une fois, puis le répète tant que la condition spécifiée reste vraie. La vérification de la condition s’effectue après chaque exécution du bloc de code.
for…in	for (propriété in objet) { // Instructions }	Parcourt les propriétés d’un objet et exécute le bloc de code pour chaque propriété.
for…of	for (élément of itérable) { // Instructions }	Parcourt les éléments d’un objet itérable, comme un tableau, une chaîne de caractères ou une Map, et exécute le bloc de code pour chaque élément.

Introduction à l’Instruction « break »

L’instruction `break` permet d’interrompre l’exécution d’une boucle de manière prématurée. Lorsque cette instruction est rencontrée, la boucle est instantanément arrêtée et le programme poursuit son exécution avec la première instruction qui suit la boucle.

L’instruction `break` est particulièrement utile pour arrêter une boucle lorsque une situation inattendue se produit, plutôt que d’attendre que la boucle atteigne son terme naturel. La syntaxe de cette instruction est d’une grande simplicité :

break;

Comment Utiliser « break » dans les Différentes Boucles JavaScript

Les exemples suivants illustrent l’utilisation de l’instruction `break` pour interrompre chacune des boucles disponibles en JavaScript. Prenez note des valeurs des variables locales et de leur état au moment de l’arrêt de la boucle.

Interrompre une Boucle `for`

const chiffres = [1, 2, 3, 4, 5];
let somme = 0;for (let i = 0; i < chiffres.length; i++)
{
  somme += chiffres[i];
  if (somme > 5)
  {
    break;
  }
}
console.log(somme);

Ce code somme les éléments d’un tableau à l’aide d’une boucle `for`. La boucle itère sur chaque élément, en l’ajoutant à la somme. Une condition vérifie si la somme dépasse la valeur de 5. Si c’est le cas, l’instruction `break` interrompt la boucle.

Interrompre une Boucle `while`

const chiffres = [1, 2, 3, 4, 5];
let produit = 1;
let i = 0;while (i < chiffres.length)
{
  produit *= chiffres[i];
  if (produit > 10)
  {
    break;
  }
  i++;
}
console.log(produit);

Ce code utilise une boucle `while` pour calculer le produit des éléments d’un tableau. La boucle parcourt chaque élément, et une instruction `break` située dans une condition, arrête la boucle lorsque le produit dépasse la valeur de 10.

Interrompre une Boucle `do…while`

let i = 1;do
{
  if (i % 2 === 0)
  {
    console.log(i);
  }
  i++;
  if (i > 5)
  {
    break;
  }
} while (i <= 10);

La boucle `do…while` itère sur les nombres de 1 à 10 et affiche les nombres pairs. L’instruction `break` dans la condition if vérifie si le compteur de la boucle est supérieur à 5 et interrompt la boucle si la condition est vraie.

Interrompre une Boucle `for…in`

const phrase = "Bonjour";
let resultat = "";for (let index in phrase)
{
  if (index == 2)
  {
    break;
  }
  resultat += phrase[index];
}
console.log(resultat);

Cette boucle parcourt chaque caractère d’une chaîne, en les concaténant. La condition ici teste si l’index de la boucle est égal à 2. Si c’est le cas, elle quitte la boucle à l’aide de l’instruction `break`.

Interrompre une Boucle `for…of`

const chiffres = [1, 2, 3, 4, 5];for (let num of chiffres.reverse())
{
  console.log(num);
  if (num === 3)
  {
    break;
  }
}

Cette boucle parcourt chaque élément du tableau en ordre inverse. Si la boucle rencontre la valeur 3, elle se termine via l’instruction `break`.

L’Importance d’Interrompre les Boucles

Sortir d’une boucle peut être un moyen efficace d’optimiser votre code. Interrompre une boucle avant son terme permet d’éviter des itérations inutiles, de réduire la complexité temporelle, et de faciliter la gestion des erreurs.

Entraînez-vous à interrompre les différentes boucles JavaScript dans vos programmes afin de consolider vos acquis.

0 Partages