Structures de contrôle (conditionnelles, boucles)

Diriger le flux d'exécution : Les structures de contrôle

Une fois que vous savez déclarer des variables, manipuler différents types de données et utiliser des opérateurs, l'étape suivante consiste à contrôler comment et quand certaines parties de votre code sont exécutées. C'est le rôle des structures de contrôle. Elles permettent à votre programme de prendre des décisions (conditionnelles) et de répéter des actions (boucles), formant ainsi la logique fondamentale de toute application, y compris celles développées avec Node.js.

Sans structures de contrôle, un script s'exécuterait simplement de haut en bas, ligne par ligne. Les structures conditionnelles introduisent des embranchements basés sur la véracité de certaines expressions, tandis que les boucles permettent d'exécuter un bloc de code plusieurs fois, soit un nombre défini de fois, soit tant qu'une certaine condition est remplie. Maîtriser ces structures est essentiel pour créer des programmes dynamiques et réactifs.

Prendre des décisions : Instructions conditionnelles

L'instruction `if...else` : C'est la structure conditionnelle la plus fondamentale. Elle permet d'exécuter un bloc de code si une condition est vraie (`true`), et éventuellement un autre bloc si elle est fausse (`false`).

const temperature = 15;

if (temperature > 25) {
  console.log("Il fait chaud !");
} else if (temperature > 10) {
  console.log("Il fait bon.");
} else {
  console.log("Il fait froid.");
}
// Résultat affiché : "Il fait bon."

JavaScript évalue la condition en termes de valeurs "truthy" et "falsy". Une valeur est "falsy" si elle est `false`, `0`, `""` (chaîne vide), `null`, `undefined` ou `NaN`. Toutes les autres valeurs, y compris les objets et les tableaux (même vides), sont "truthy".

let utilisateur = null;
if (utilisateur) { // utilisateur est null (falsy)
  console.log("Utilisateur trouvé");
} else {
  console.log("Utilisateur non trouvé");
}
// Résultat affiché : "Utilisateur non trouvé"

let panier = [];
if (panier) { // panier est un tableau (truthy, même vide)
  console.log("Panier existe");
}
// Résultat affiché : "Panier existe" (Attention : pour vérifier si un tableau est vide, on teste sa longueur `panier.length === 0`)

L'instruction `switch` : Utile lorsque vous devez tester une seule variable (ou expression) contre plusieurs valeurs possibles (`case`). Elle est souvent plus lisible qu'une longue série de `if...else if`.

const statutCommande = "expédiée";
let message;

switch (statutCommande) {
  case "en attente":
    message = "Votre commande est en attente de traitement.";
    break; // Important ! Sans break, l'exécution continue aux cas suivants.
  case "traitée":
    message = "Votre commande est en cours de préparation.";
    break;
  case "expédiée":
    message = "Votre commande a été expédiée.";
    break;
  case "livrée":
    message = "Votre commande a été livrée.";
    break;
  default: // Cas par défaut si aucune correspondance
    message = "Statut de commande inconnu.";
}

console.log(message); 
// Résultat affiché : "Votre commande a été expédiée."

N'oubliez jamais l'instruction `break` à la fin de chaque `case` (sauf si vous souhaitez intentionnellement un comportement de "fall-through"). Le `default` est optionnel mais recommandé pour gérer les cas imprévus.

Répéter des actions : Boucles

Les boucles permettent d'exécuter un bloc de code de manière répétée.

La boucle `for` classique : Idéale lorsque vous savez combien de fois vous voulez itérer.

// Affiche les nombres de 0 à 4
for (let i = 0; i < 5; i++) { 
  // i = 0 : initialisation, exécutée une seule fois au début
  // i < 5 : condition, vérifiée avant chaque itération
  // i++   : expression finale, exécutée après chaque itération
  console.log(i);
}
// Output:
// 0
// 1
// 2
// 3
// 4

La boucle `while` : Exécute un bloc de code tant qu'une condition spécifiée est vraie. La condition est vérifiée avant chaque itération.

let tentatives = 3;
while (tentatives > 0) {
  console.log(`Tentatives restantes : ${tentatives}`);
  tentatives--; // Important : assurez-vous que la condition finira par devenir fausse !
}
console.log("Plus de tentatives.");
// Output:
// Tentatives restantes : 3
// Tentatives restantes : 2
// Tentatives restantes : 1
// Plus de tentatives.

Attention aux boucles infinies si la condition ne devient jamais fausse !

La boucle `do...while` : Similaire à `while`, mais la condition est vérifiée après l'exécution du bloc. Cela garantit que le bloc de code est exécuté au moins une fois.

let saisieValide = false;
do {
  console.log("Veuillez entrer une valeur (simulation).");
  // Ici, on simulerait une saisie utilisateur et on mettrait saisieValide à true si elle est correcte
  // Pour l'exemple, on la met à true directement
  saisieValide = true; 
} while (!saisieValide);
console.log("Saisie validée.");
// Output:
// Veuillez entrer une valeur (simulation).
// Saisie validée.

Cette boucle est moins fréquente mais utile dans certains scénarios comme la validation d'entrée utilisateur.

Itérer sur des collections : Boucles `for...in` et `for...of`

JavaScript propose des boucles spécifiques pour parcourir les éléments de collections (objets, tableaux, etc.).

La boucle `for...in` : Itère sur les noms des propriétés énumérables d'un objet. L'ordre d'itération n'est pas garanti.

const voiture = {
  marque: "Renault",
  modele: "Clio",
  annee: 2022
};

for (const cle in voiture) {
  console.log(`${cle}: ${voiture[cle]}`); 
}
// Output (l'ordre peut varier) :
// marque: Renault
// modele: Clio
// annee: 2022

Attention : `for...in` itère aussi sur les propriétés héritées du prototype. Pour éviter cela, on ajoute souvent une vérification avec `hasOwnProperty()` :

for (const cle in voiture) {
  if (Object.hasOwnProperty.call(voiture, cle)) { // Ou voiture.hasOwnProperty(cle) s'il n'y a pas de risque d'écrasement
     console.log(`${cle}: ${voiture[cle]}`); 
  }
}

N'utilisez PAS `for...in` pour itérer sur des tableaux, car il itère sur les indices (qui sont des chaînes) et les propriétés ajoutées au tableau, et l'ordre n'est pas garanti.

La boucle `for...of` (ES6) : C'est la manière moderne et recommandée d'itérer sur les valeurs des objets itérables (comme les `Array`, `String`, `Map`, `Set`, etc.).

const couleurs = ["rouge", "vert", "bleu"];

// Itérer sur un tableau
for (const couleur of couleurs) {
  console.log(couleur);
}
// Output:
// rouge
// vert
// bleu

const message = "Node";

// Itérer sur une chaîne de caractères
for (const caractere of message) {
  console.log(caractere);
}
// Output:
// N
// o
// d
// e

// Note: Les objets simples ne sont pas itérables par défaut avec for...of
// const monObjet = { a: 1, b: 2 };
// for (const valeur of monObjet) { // TypeError: monObjet is not iterable }
// Pour itérer sur les valeurs d'un objet, utilisez Object.values(), Object.keys(), ou Object.entries() avec for...of
const monObjet = { a: 1, b: 2 };
for (const valeur of Object.values(monObjet)) {
  console.log(valeur); // 1, puis 2
}
for (const [cle, valeur] of Object.entries(monObjet)) {
  console.log(`${cle}: ${valeur}`); // a: 1, puis b: 2
}

Préférez `for...of` pour parcourir les tableaux et autres structures de données itérables.

Contrôler le flux dans les boucles : `break` et `continue`

Parfois, vous avez besoin de modifier le comportement normal d'une boucle.

• `break` : Permet de sortir immédiatement de la boucle (`for`, `while`, `do...while`) ou de l'instruction `switch` en cours. L'exécution reprend à l'instruction qui suit la boucle terminée.

const nombres = [1, 5, -3, 8, 2];
for (const nb of nombres) {
  if (nb < 0) {
    console.log("Nombre négatif trouvé, arrêt de la boucle.");
    break; // Sort de la boucle for...of
  }
  console.log(`Traitement de ${nb}`);
}
// Output:
// Traitement de 1
// Traitement de 5
// Nombre négatif trouvé, arrêt de la boucle.

• `continue` : Permet de sauter le reste de l'itération actuelle de la boucle et de passer directement à l'itération suivante.

const notes = [12, 8, 15, 5, 10];
for (const note of notes) {
  if (note < 10) {
    console.log(`Note ${note} insuffisante, ignorée.`);
    continue; // Passe à la note suivante
  }
  console.log(`Traitement de la note ${note}.`);
}
// Output:
// Traitement de la note 12.
// Note 8 insuffisante, ignorée.
// Traitement de la note 15.
// Note 5 insuffisante, ignorée.
// Traitement de la note 10.

Ces structures de contrôle conditionnelles et répétitives sont les outils fondamentaux pour construire la logique de vos applications Node.js, vous permettant de gérer différents scénarios, de traiter des collections de données et d'automatiser des tâches répétitives.