Conditions et boucles : if, switch, for…of, while

Les conditions (if, switch, l'opérateur ternaire) choisissent quel code exécuter ; les boucles (for, for…of, for…in, while) répètent un bloc. Ce chapitre montre leur syntaxe en JavaScript et les pièges propres au langage. Si les notions de condition et de boucle sont encore floues pour toi, commence par les chapitres Si, alors, sinon et Boucles pour, tant que du cours d'algorithmique : on n'y revient pas ici.

Les exemples utilisent le stock de Gestock, rangé dans un tableau d'objets. Tu verras les tableaux et les objets en détail aux chapitres 5 et 6 ; pour l'instant, retiens que pieces[0] est la première pièce et que pieces[0].quantite est sa quantité.

const pieces = [
  { ref: 'SSD-512', nom: 'SSD NVMe 512 Go', categorie: 'Stockage', quantite: 12, seuil: 5, prix: 42.9 },
  { ref: 'RAM-16', nom: 'Barrette DDR4 16 Go', categorie: 'Mémoire', quantite: 3, seuil: 4, prix: 38.5 },
  { ref: 'CHG-65', nom: 'Chargeur USB-C 65 W', categorie: 'Alimentation', quantite: 0, seuil: 2, prix: 24 },
  { ref: 'ECR-156', nom: 'Dalle 15,6 pouces', categorie: 'Écran', quantite: 2, seuil: 1, prix: 89 },
  { ref: 'PAT-01', nom: 'Pâte thermique', categorie: 'Consommable', quantite: 25, seuil: 10, prix: 6.5 },
];

if, else if, else

function statut(quantite, seuil) {
  if (quantite === 0) {
    return 'rupture';
  } else if (quantite <= seuil) {
    return 'alerte';
  } else {
    return 'ok';
  }
}

statut(12, 5);   // 'ok'
statut(3, 4);    // 'alerte'
statut(0, 2);    // 'rupture'

La condition s'écrit entre parenthèses, le bloc entre accolades. Les conditions sont testées dans l'ordre et seul le premier bloc dont la condition est vraie s'exécute : c'est pour cela que la rupture (quantite === 0) est testée avant l'alerte, sinon une pièce à 0 serait classée « alerte » (0 est bien inférieur au seuil).

Les accolades sont facultatives quand le bloc ne contient qu'une instruction (if (quantite === 0) return 'rupture';). Garde-les dès que tu hésites : une deuxième ligne ajoutée plus tard sans accolades s'exécuterait toujours, quel que soit le résultat du test.

Pour combiner des conditions, utilise && (et), || (ou) et ! (non), en ajoutant des parenthèses dès que tu mélanges && et || :

const p = pieces[1];
if (p.quantite <= p.seuil && (p.categorie === 'Mémoire' || p.categorie === 'Stockage')) {
  console.log(`Commande urgente : ${p.ref}`);   // Commande urgente : RAM-16
}

Le retour anticipé : éviter les if imbriqués

Quand une fonction doit vérifier plusieurs choses avant de travailler, sors dès qu'une vérification échoue. Le code se lit de haut en bas au lieu de s'enfoncer dans des else :

function retirerUnite(piece) {
  if (!piece) return 'Pièce introuvable';
  if (piece.quantite === 0) return `${piece.ref} est en rupture`;
  piece.quantite -= 1;
  return `${piece.ref} : il en reste ${piece.quantite}`;
}

L'opérateur ternaire

Le ternaire condition ? valeurSiVrai : valeurSiFaux est un if…else qui produit une valeur. Il sert à choisir une valeur dans une expression, pas à enchaîner des actions :

const q = 1;
const texte = q > 1 ? `${q} pièces` : `${q} pièce`;   // '1 pièce'

N'imbrique pas les ternaires (a ? b : c ? d : e) : au-delà de deux cas, un if ou un switch se lit mieux.

switch : choisir parmi plusieurs valeurs

switch compare une valeur à plusieurs cas avec l'égalité stricte === :

function delaiLivraison(categorie) {
  switch (categorie) {
    case 'Stockage':
    case 'Mémoire':
      return 2;          // deux cas regroupés
    case 'Écran':
      return 7;
    default:
      return 3;          // toutes les autres catégories
  }
}

delaiLivraison('Mémoire');       // 2
delaiLivraison('Alimentation');  // 3

Dans une fonction, return sort directement du switch. Hors d'une fonction, chaque cas doit se terminer par break, sinon l'exécution continue dans le cas suivant (on parle de fall-through) :

let libelle = '';
switch (1) {
  case 1:
    libelle = 'un';      // pas de break…
  case 2:
    libelle = 'deux';    // … donc on exécute aussi cette ligne
    break;
  default:
    libelle = '?';
}
console.log(libelle);    // 'deux'

Quand chaque cas se contente de donner une valeur, un objet de correspondance est souvent plus court qu'un switch :

const DELAIS = { Stockage: 2, Mémoire: 2, Écran: 7 };
const delai = DELAIS['Écran'] ?? 3;          // 7
const autre = DELAIS['Alimentation'] ?? 3;   // 3 : catégorie absente, valeur par défaut

La boucle for classique

La boucle for à compteur répète un bloc tant qu'une condition est vraie. Elle a trois parties : l'initialisation, la condition, l'incrément.

let nbAlertes = 0;
for (let i = 0; i < pieces.length; i++) {
  if (pieces[i].quantite <= pieces[i].seuil) {
    nbAlertes++;
  }
}
console.log(nbAlertes);   // 2 (RAM-16 et CHG-65)

Les indices d'un tableau vont de 0 à pieces.length - 1 : la condition est donc i < pieces.length, avec un < strict. Écrire i <= pieces.length fait un tour de trop, où pieces[i] vaut undefined, et undefined.quantite arrête le script sur une TypeError.

for…of : parcourir un tableau ou une chaîne

Quand tu n'as pas besoin de l'indice, for…of donne directement chaque élément. C'est la boucle à utiliser par défaut sur un tableau :

for (const p of pieces) {
  console.log(`${p.ref} : ${statut(p.quantite, p.seuil)}`);
}

SSD-512 : ok
RAM-16 : alerte
CHG-65 : rupture
ECR-156 : ok
PAT-01 : ok

La variable de boucle peut être une const : elle est recréée à chaque tour. for…of parcourt aussi les caractères d'une chaîne (for (const lettre of 'RAM') donne R, A, M), les Map et les Set (chapitre 6). Si tu as besoin de l'indice en plus, utilise entries() :

for (const [i, p] of pieces.entries()) {
  console.log(`${i + 1}. ${p.ref}`);   // 1. SSD-512, 2. RAM-16…
}

for…in : parcourir les propriétés d'un objet

for…in parcourt les noms des propriétés d'un objet :

const piece = pieces[0];
for (const cle in piece) {
  console.log(`${cle} = ${piece[cle]}`);
}

ref = SSD-512
nom = SSD NVMe 512 Go
categorie = Stockage
quantite = 12
seuil = 5
prix = 42.9

while et do…while

while répète tant qu'une condition est vraie, quand on ne connaît pas le nombre de tours à l'avance. Combien de jours avant de passer sous le seuil, si l'atelier consomme 3 SSD par jour ?

let stock = 12;
let jours = 0;
while (stock > 5) {
  stock -= 3;
  jours++;
}
console.log(stock, jours);   // 3 3

do…while exécute le bloc une première fois avant de tester la condition : utile pour redemander une saisie jusqu'à ce qu'elle soit correcte, rare dans une page web où l'on attend plutôt un événement.

break et continue

break sort immédiatement de la boucle ; continue passe au tour suivant.

for (const p of pieces) {
  if (p.quantite === 0) {
    console.log(`Première rupture : ${p.ref}`);   // Première rupture : CHG-65
    break;
  }
}

let unites = 0;
for (const p of pieces) {
  if (p.categorie === 'Consommable') continue;     // on ignore la pâte thermique
  unites += p.quantite;
}
console.log(unites);   // 17

Quelle boucle choisir ?

Dans un code JavaScript moderne, les boucles explicites reculent au profit des méthodes de tableau du chapitre 5, plus courtes et plus lisibles. Mais elles restent indispensables dès qu'il faut s'arrêter en route (break), et ce sont elles que tu écris en algorithmique et à l'écrit de l'E7, où le code se lit et s'écrit sur papier.

Fil rouge : le statut de chaque pièce

Gestock affichera un statut pour chaque pièce. Avec la fonction statut de ce chapitre et une boucle, compte les pièces de chaque statut :

let ok = 0;
let alerte = 0;
let rupture = 0;
for (const p of pieces) {
  switch (statut(p.quantite, p.seuil)) {
    case 'rupture':
      rupture++;
      break;
    case 'alerte':
      alerte++;
      break;
    default:
      ok++;
  }
}
console.log(`ok : ${ok}, alerte : ${alerte}, rupture : ${rupture}`);
// ok : 3, alerte : 1, rupture : 1

Attention à la différence de vocabulaire : ici, CHG-65 compte comme « rupture » et non comme « alerte ». Dans le reste du cours, une pièce est en alerte dès que sa quantité est inférieure ou égale au seuil, rupture comprise : RAM-16 et CHG-65.

Exercices

let sortie = '';
for (let i = 1; i <= 10; i++) {
  if (i % 4 === 0) break;
  if (i % 2 === 0) continue;
  sortie += i + ' ';
}
console.log(sortie);

function tauxRemise(unites) {
  if (unites >= 50) return 10;
  if (unites >= 10) return 5;
  return 0;
}

for (let i = 0; i <= pieces.length; i++) {
  console.log(pieces[i].ref);
}

for (const p of pieces) {
  console.log(p.ref);
}