Explorer les structures de boucles en JavaScript

JavaScriptJavaScriptBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, les étudiants plongeront profondément dans les structures de boucles JavaScript, explorant diverses techniques d'itération qui sont fondamentales pour la logique de programmation. Le laboratoire couvre les types de boucles essentiels, y compris les boucles while, do-while, for et for-in, en offrant une expérience pratique avec chaque structure grâce à des exemples de codage pratiques et à un apprentissage progressif.

Les participants commenceront par comprendre la syntaxe de base des boucles while, en apprenant à créer des itérations contrôlées et à effectuer des tâches telles que le comptage et la recherche conditionnelle. Au fur et à mesure qu'ils progressent, ils pratiqueront la mise en œuvre de différentes structures de boucles, en comparant leurs caractéristiques et leurs cas d'utilisation uniques, ce qui leur aidera à développer une compréhension globale de la manière dont les boucles peuvent être utilisées pour manipuler des données, itérer à travers des tableaux et créer des solutions de programmation dynamique en JavaScript.

Comprendre la syntaxe et l'utilisation de base des boucles while

Dans cette étape, vous allez apprendre la syntaxe et l'utilisation de base des boucles while en JavaScript. Les boucles while sont des structures de contrôle fondamentales qui vous permettent de répéter un bloc de code tant qu'une condition spécifiée est vraie.

Commençons par créer un nouveau fichier JavaScript pour explorer les boucles while. Ouvrez l'IDE Web et créez un fichier nommé whileLoop.js dans le répertoire ~/project.

// Crée une boucle while simple pour compter de 1 à 5
let count = 1;

while (count <= 5) {
  console.log(`Compteur actuel : ${count}`);
  count++;
}

Maintenant, exécutez le fichier JavaScript à l'aide de Node.js pour voir la sortie :

node ~/project/whileLoop.js

Sortie exemple :

Compteur actuel : 1
Compteur actuel : 2
Compteur actuel : 3
Compteur actuel : 4
Compteur actuel : 5

Analysons la syntaxe de la boucle while :

  • let count = 1; initialise une variable compteur avant la boucle
  • while (count <= 5) définit la condition qui doit être vraie pour continuer à boucler
  • console.log() affiche la valeur actuelle de count
  • count++ incrémente le compteur à chaque itération

Maintenant, créons un exemple plus pratique qui montre une boucle while avec une condition plus complexe :

// Crée une boucle while pour trouver le premier nombre divisible par 3 et 5
let number = 1;

while (!(number % 3 === 0 && number % 5 === 0)) {
  number++;
}

console.log(`Premier nombre divisible par 3 et 5 : ${number}`);

Exécutez le fichier à nouveau :

node ~/project/whileLoop.js

Sortie exemple :

Premier nombre divisible par 3 et 5 : 15

Cet exemple montre comment les boucles while peuvent être utilisées pour rechercher des conditions spécifiques ou effectuer des tâches itératives.

Pratiquer la boucle do-while avec itération incrémentale

Dans cette étape, vous allez apprendre les boucles do-while en JavaScript, qui sont similaires aux boucles while mais présentent une différence clé : le bloc de code est exécuté au moins une fois avant de vérifier la condition.

Créez un nouveau fichier nommé doWhileLoop.js dans le répertoire ~/project à l'aide de l'IDE Web :

// Démontre une boucle do-while avec simulation d'entrée utilisateur
let attempts = 0;
let secretNumber = 7;
let guess;

do {
  // Simule un devinage aléatoire entre 1 et 10
  guess = Math.floor(Math.random() * 10) + 1;
  attempts++;

  console.log(`Essai ${attempts} : Deviné ${guess}`);

  if (guess === secretNumber) {
    console.log(
      `Félicitations! Vous avez deviné le nombre en ${attempts} essais.`
    );
  }
} while (guess !== secretNumber);

Exécutez le fichier JavaScript pour voir comment fonctionne la boucle do-while :

node ~/project/doWhileLoop.js

Sortie exemple :

Essai 1 : Deviné 3
Essai 2 : Deviné 9
Essai 3 : Deviné 7
Félicitations! Vous avez deviné le nombre en 3 essais.

Caractéristiques clés des boucles do-while :

  • Le bloc de code est exécuté au moins une fois avant de vérifier la condition
  • La condition est vérifiée à la fin de chaque itération
  • Utile lorsque vous voulez vous assurer que le code s'exécute au moins une fois

Créons un autre exemple pour illustrer davantage la boucle do-while :

// Démontre l'itération incrémentale avec la boucle do-while
let total = 0;
let i = 1;

do {
  total += i;
  console.log(`Total actuel : ${total}, Nombre actuel : ${i}`);
  i++;
} while (total < 10);

console.log(`Total final : ${total}`);

Exécutez le fichier à nouveau :

node ~/project/doWhileLoop.js

Sortie exemple :

Total actuel : 1, Nombre actuel : 1
Total actuel : 3, Nombre actuel : 2
Total actuel : 6, Nombre actuel : 3
Total actuel : 10, Nombre actuel : 4
Total final : 10

Cet exemple montre comment les boucles do-while peuvent être utilisées pour l'itération incrémentale, en vous assurant que le bloc de code s'exécute au moins une fois avant de vérifier la condition de terminaison.

Implémenter la boucle for pour des itérations contrôlées

Dans cette étape, vous allez apprendre les boucles for en JavaScript, qui offrent un moyen concis de réaliser des itérations contrôlées avec un mécanisme de début, de fin et d'incrémentation/décrémentation clair.

Créez un nouveau fichier nommé forLoop.js dans le répertoire ~/project à l'aide de l'IDE Web :

// Boucle for de base pour afficher les nombres de 1 à 5
console.log("Boucle de comptage de base :");
for (let i = 1; i <= 5; i++) {
  console.log(`Nombre actuel : ${i}`);
}

// Boucle for pour calculer la factorielle d'un nombre
console.log("\nCalcul de la factorielle :");
let number = 5;
let factorial = 1;

for (let j = 1; j <= number; j++) {
  factorial *= j;
}

console.log(`La factorielle de ${number} est : ${factorial}`);

// Boucle for pour itérer à travers un tableau
console.log("\nItération sur un tableau :");
let fruits = ["pomme", "banane", "cerise", "date"];

for (let k = 0; k < fruits.length; k++) {
  console.log(`Fruit à l'index ${k} : ${fruits[k]}`);
}

Exécutez le fichier JavaScript pour voir les différents exemples de boucle for :

node ~/project/forLoop.js

Sortie exemple :

Boucle de comptage de base :
Nombre actuel : 1
Nombre actuel : 2
Nombre actuel : 3
Nombre actuel : 4
Nombre actuel : 5

Calcul de la factorielle :
La factorielle de 5 est : 120

Itération sur un tableau :
Fruit à l'index 0 : pomme
Fruit à l'index 1 : banane
Fruit à l'index 2 : cerise
Fruit à l'index 3 : date

Analysons la syntaxe de la boucle for :

  • for (initialisation ; condition ; incrémentation/décrémentation) est la structure standard
  • let i = 1 initialise le compteur de boucle
  • i <= 5 définit la condition de continuation
  • i++ incrémente le compteur après chaque itération

Créez un autre exemple montrant une utilisation plus complexe de la boucle for :

// Boucle for imbriquée pour créer une table de multiplication
console.log("Table de multiplication :");
for (let row = 1; row <= 5; row++) {
  let rowOutput = "";
  for (let col = 1; col <= 5; col++) {
    rowOutput += `${row * col}\t`;
  }
  console.log(rowOutput);
}

Exécutez le fichier à nouveau :

node ~/project/forLoop.js

Sortie exemple :

Table de multiplication :
1	2	3	4	5
2	4	6	8	10
3	6	9	12	15
4	8	12	16	20
5	10	15	20	25

Cet exemple montre comment les boucles for imbriquées peuvent être utilisées pour créer des modèles d'itération plus complexes.

Utiliser la boucle for-in pour itérer sur les éléments d'un tableau

Dans cette étape, vous allez apprendre la boucle for-in en JavaScript, qui fournit un moyen simple d'itérer sur les propriétés d'un objet ou les éléments d'un tableau.

Créez un nouveau fichier nommé forInLoop.js dans le répertoire ~/project à l'aide de l'IDE Web :

// Itération sur un tableau à l'aide de la boucle for-in
let fruits = ["pomme", "banane", "cerise", "date"];

console.log("Itération sur les indices du tableau :");
for (let index in fruits) {
  console.log(`Index : ${index}, Fruit : ${fruits[index]}`);
}

// Itération sur un objet à l'aide de la boucle for-in
let student = {
  name: "John Doe",
  age: 22,
  major: "Informatique",
  gpa: 3.8
};

console.log("\nItération sur les propriétés de l'objet :");
for (let property in student) {
  console.log(`${property} : ${student[property]}`);
}

// Exemple pratique : Calcul du prix total des articles
let shoppingCart = [
  { name: "Ordinateur portable", price: 1000 },
  { name: "Ecouteurs", price: 100 },
  { name: "Souris", price: 50 }
];

console.log("\nCalcul du prix total :");
let totalPrice = 0;
for (let index in shoppingCart) {
  totalPrice += shoppingCart[index].price;
}
console.log(`Prix total : ${totalPrice} $`);

Exécutez le fichier JavaScript pour voir la boucle for-in en action :

node ~/project/forInLoop.js

Sortie exemple :

Itération sur les indices du tableau :
Index : 0, Fruit : pomme
Index : 1, Fruit : banane
Index : 2, Fruit : cerise
Index : 3, Fruit : date

Itération sur les propriétés de l'objet :
name : John Doe
age : 22
major : Informatique
gpa : 3.8

Calcul du prix total :
Prix total : 1150 $

Points clés sur les boucles for-in :

  • Fonctionne avec les tableaux et les objets
  • Itère sur les indices (pour les tableaux) ou les propriétés (pour les objets)
  • Fournit un moyen simple d'accéder aux éléments sans utiliser les boucles traditionnelles basées sur les indices
  • Faites attention lorsqu'elles sont utilisées avec les tableaux, car elles itèrent sur toutes les propriétés énumérables

Explorons un autre exemple pour démontrer sa flexibilité :

// Utilisation de la boucle for-in pour filtrer et transformer des données
let grades = {
  math: 85,
  science: 92,
  english: 78,
  history: 88
};

console.log("Filtrer les notes supérieures à 80 :");
for (let subject in grades) {
  if (grades[subject] > 80) {
    console.log(`${subject} : ${grades[subject]}`);
  }
}

Exécutez le fichier à nouveau :

node ~/project/forInLoop.js

Sortie exemple :

Filtrer les notes supérieures à 80 :
math : 85
science : 92
history : 88

Comparer et contraster différentes structures de boucles

Dans cette étape, vous allez explorer les différences entre diverses structures de boucles en JavaScript et apprendre quand utiliser efficacement chaque type de boucle.

Créez un nouveau fichier nommé loopComparison.js dans le répertoire ~/project à l'aide de l'IDE Web :

// Démontre différentes structures de boucles pour la même tâche

// 1. Boucle While : Idéale pour un nombre inconnu d'itérations
console.log("Exemple de boucle While :");
let whileCounter = 1;
while (whileCounter <= 5) {
  console.log(`Boucle While : ${whileCounter}`);
  whileCounter++;
}

// 2. Boucle Do-While : Assure au moins une exécution
console.log("\nExemple de boucle Do-While :");
let doWhileCounter = 1;
do {
  console.log(`Boucle Do-While : ${doWhileCounter}`);
  doWhileCounter++;
} while (doWhileCounter <= 5);

// 3. Boucle For : Idéale pour un nombre connu d'itérations
console.log("\nExemple de boucle For :");
for (let forCounter = 1; forCounter <= 5; forCounter++) {
  console.log(`Boucle For : ${forCounter}`);
}

// 4. Boucle For-In : Itération sur les propriétés d'un objet
console.log("\nExemple de boucle For-In :");
let student = {
  name: "John Doe",
  age: 22,
  major: "Informatique"
};

for (let property in student) {
  console.log(`${property} : ${student[property]}`);
}

// 5. Comparaison des performances des boucles
console.log("\nComparaison des performances des boucles :");
const iterations = 1000000;

console.time("Boucle While");
let a = 0;
while (a < iterations) {
  a++;
}
console.timeEnd("Boucle While");

console.time("Boucle For");
for (let b = 0; b < iterations; b++) {}
console.timeEnd("Boucle For");

Exécutez le fichier JavaScript pour voir la comparaison :

node ~/project/loopComparison.js

Sortie exemple :

Exemple de boucle While :
Boucle While : 1
Boucle While : 2
Boucle While : 3
Boucle While : 4
Boucle While : 5

Exemple de boucle Do-While :
Boucle Do-While : 1
Boucle Do-While : 2
Boucle Do-While : 3
Boucle Do-While : 4
Boucle Do-While : 5

Exemple de boucle For :
Boucle For : 1
Boucle For : 2
Boucle For : 3
Boucle For : 4
Boucle For : 5

Exemple de boucle For-In :
name : John Doe
age : 22
major : Informatique

Comparaison des performances des boucles :
Boucle While : 2,345ms
Boucle For : 1,876ms

Différences clés :

  1. Boucle While :

    • Utiliser lorsqu'on ne connaît pas le nombre d'itérations
    • Condition vérifiée avant chaque itération
    • Peut ne pas s'exécuter si la condition est fausse au départ
  2. Boucle Do-While :

    • Garantit au moins une exécution
    • Condition vérifiée après chaque itération
    • Utile lorsque l'on veut exécuter le code au moins une fois
  3. Boucle For :

    • La meilleure pour un nombre connu d'itérations
    • Syntaxe compacte avec initialisation, condition et incrémentation
    • La plus couramment utilisée pour l'itération sur des tableaux et le comptage
  4. Boucle For-In :

    • Spécifiquement pour itérer sur les propriétés d'un objet
    • Fonctionne avec les objets et les tableaux
    • Fournit les noms d'index ou de propriétés

Créons un dernier exemple pour démontrer le choix de la bonne boucle :

// Choix de la bonne boucle pour différents scénarios
let numbers = [10, 20, 30, 40, 50];

// Boucle While pour une recherche conditionnelle
console.log("\nChoix de la bonne boucle :");
let searchValue = 30;
let index = 0;
while (index < numbers.length && numbers[index] !== searchValue) {
  index++;
}
console.log(`Trouvé ${searchValue} à l'index : ${index}`);

// Boucle For pour une itération simple
console.log("Nombres au carré :");
for (let i = 0; i < numbers.length; i++) {
  console.log(`${numbers[i]} au carré : ${numbers[i] * numbers[i]}`);
}

Exécutez le fichier à nouveau :

node ~/project/loopComparison.js

Sortie exemple :

Choix de la bonne boucle :
Trouvé 30 à l'index : 2
Nombres au carré :
10 au carré : 100
20 au carré : 400
30 au carré : 900
40 au carré : 1600
50 au carré : 2500

Sommaire

Dans ce laboratoire, les participants ont exploré diverses structures de boucles en JavaScript, en mettant l'accent sur la compréhension et la mise en œuvre de différents types de boucles. Le laboratoire a commencé par une étude approfondie des boucles while, en démontrant leur syntaxe de base et leurs applications pratiques grâce à des exemples qui comptent les itérations et recherchent des conditions numériques spécifiques. Les participants ont appris à initialiser les variables de boucle, à définir les conditions de boucle et à utiliser les opérateurs d'incrémentation pour contrôler l'exécution de la boucle.

Le laboratoire s'est poursuivi avec l'étude d'autres types de boucles, y compris les boucles do-while, for et for-in, en offrant une expérience pratique avec chaque structure. En comparant et en contrastant ces mécanismes de boucles, les apprenants ont acquis des connaissances sur la sélection de structures de boucles appropriées pour différents scénarios de programmation, améliorant ainsi leurs compétences en programmation JavaScript et leur compréhension des mécanismes de flux de contrôle.