Écrire cent fois la même ligne n'est pas une option. La boucle est la construction qui permet à quinze lignes d'algorithme de traiter un million de données — et c'est précisément ce qui rend une machine utile.

Tant que : répéter jusqu'à ce que la condition tombe

1TantQue condition Faire2    ...instructions...3FinTantQue

Le mécanisme tient en trois temps, et l'ordre compte. On évalue la condition. Si elle est VRAIE, on exécute le corps, puis on revient au test. Si elle est FAUSSE, on saute directement après le FinTantQue.

Conséquence importante : le test a lieu avant le corps. Si la condition est fausse dès le départ, le corps n'est jamais exécuté. Zéro tour est un résultat parfaitement normal, et souvent le comportement correct — une boucle qui traite les éléments d'une liste vide ne doit rien faire.

Compteur et accumulateur

Presque toute boucle utile met en scène deux rôles distincts, qu'il faut apprendre à distinguer.

Le compteur sait où on en est : i ← i + 1 à chaque tour. Il ne dépend pas du contenu traité, seulement du nombre de tours effectués.

L'accumulateur garde la mémoire de ce qui a été traité : somme ← somme + i. Sa valeur finale est le résultat de l'algorithme.

Les deux doivent être initialisés avant la boucle. Et cette initialisation n'est pas arbitraire : un accumulateur de somme part de 0, l'élément neutre de l'addition ; un accumulateur de produit part de 1. Partir de 0 pour un produit donnerait invariablement 0.

Cliquez l'étape 5, puis l'étape 15. Entre les deux, le même bloc de trois lignes a été parcouru quatre fois — c'est exactement ce que « boucle » veut dire. Et remarquez l'étape 15 : i vaut 5 à la sortie, pas 4. Le compteur dépasse toujours d'un cran la dernière valeur traitée, puisque c'est ce dépassement qui fait échouer le test et arrête la boucle.

La boucle infinie

Retirez la ligne i ← i + 1 de la trace précédente. i reste à 1, le test 1 ≤ 4 reste vrai, et la boucle tourne pour toujours. C'est l'erreur la plus courante du semestre, et elle viole la première exigence de la leçon 1 : la finitude.

La règle de relecture est simple : le corps de la boucle doit contenir quelque chose qui fait progresser la condition vers FAUX. Si vous ne trouvez pas cette instruction, la boucle ne s'arrêtera pas.

Pour : quand le nombre de tours est connu d'avance

1Pour i de 1 à 4 Faire2    somme ← somme + i3FinPour

Cette boucle fait exactement la même chose que la trace ci-dessus, en trois lignes au lieu de sept. Le Pour regroupe au même endroit l'initialisation du compteur, le test et l'incrément — ce qui rend l'oubli de l'incrément impossible. C'est sa vraie qualité, bien plus que la concision.

Les bornes sont incluses des deux côtés : Pour i de 1 à 4 fait quatre tours, avec i valant successivement 1, 2, 3 puis 4.

Le choix entre les deux se fait sur une seule question : sait-on compter les tours avant d'entrer dans la boucle ?

Tout Pour peut se réécrire en TantQue ; l'inverse est faux. Un Pour est un TantQue discipliné.

Cette somme des entiers de 1 à $n$ a d'ailleurs une formule fermée, connue depuis l'Antiquité :

Elle donne le même résultat que la boucle, mais en une seule opération au lieu de $n$. Gardez-la en tête : nous la retrouverons à la leçon 8, quand il s'agira de compter le travail d'un algorithme de tri.

À vous

// 1. Corrigez la boucle Tant que pour qu'elle somme les entiers de 1 à n.
// 2. Écrivez ensuite la même chose avec une boucle Pour.
function sommeTantQue(n) {
  let i = 1;
  let somme = 0;
  while (i <= 0) {   // ← condition à corriger
    // à compléter : accumuler, PUIS avancer le compteur
  }
  return somme;
}

function sommePour(n) {
  let somme = 0;
  // à compléter
  return somme;
}

console.log(sommeTantQue(4), sommePour(4));      // attendu : 10 10
console.log(sommeTantQue(100), sommePour(100));  // attendu : 5050 5050

function sommeTantQue(n) {
  let i = 1;
  let somme = 0;
  while (i <= n) {
    somme = somme + i;
    i = i + 1;       // sans cette ligne : boucle infinie
  }
  return somme;
}

// Quand le nombre de tours est connu d'avance, la boucle Pour dit la même
// chose en une ligne : déclaration, condition et avancement au même endroit,
// donc impossible d'oublier l'incrément.
function sommePour(n) {
  let somme = 0;
  for (let i = 1; i <= n; i++) {
    somme = somme + i;
  }
  return somme;
}

console.log(sommeTantQue(4), sommePour(4));
console.log(sommeTantQue(100), sommePour(100));

À retenir

Vingt notes à traiter ne justifient pas vingt variables. Le tableau est la structure qui regroupe plusieurs valeurs de même type sous un seul nom, chacune repérée par un numéro.

1Variables2    T : tableau de 5 entiers3Début4    T[0] ← 125    T[1] ← 56    ...

Deux propriétés à retenir. Toutes les cases ont le même type : un tableau d'entiers ne contient que des entiers. Et l'accès à une case est immédiat : atteindre T[3] ne coûte pas plus cher que T[0], la machine n'a pas à parcourir les cases précédentes. Ce détail paraît anodin ; c'est lui qui rendra possible la recherche dichotomique de la leçon 6.

Les cases sont numérotées de 0 à n − 1

C'est la convention de la quasi-totalité des langages, et la source d'erreur numéro un des débutants. Un tableau de 5 cases a pour indices 0, 1, 2, 3, 4. Il n'y a pas de case 5.

La première case est T[0], la dernière est T[n − 1] où n est la taille. Retenez ces deux formes plutôt que des nombres : elles restent justes quelle que soit la taille.

Accéder à T[5] sur ce tableau est un débordement d'indice. Selon le langage, le programme s'arrête net, ou — bien pire — lit un morceau de mémoire qui ne lui appartient pas et continue avec une valeur absurde.

Le parcours

Parcourir un tableau, c'est visiter ses cases une par une, dans l'ordre. Le schéma est toujours le même, et il vaut la peine de l'écrire une fois pour toutes :

1Pour i de 0 à n − 1 Faire2    ...traiter T[i]...3FinPour

Notez n − 1, pas n. Écrire Pour i de 0 à n produit un tour de trop, et ce tour déborde. C'est l'erreur « à un près », la plus fréquente et la plus discrète du semestre.

Une seule boucle a produit trois résultats. C'est un réflexe à prendre : quand plusieurs grandeurs se calculent sur les mêmes données, on ne fait pas trois parcours, on en fait un seul avec trois accumulateurs.

Somme, moyenne, minimum, maximum

Ces quatre calculs sont les exercices d'application obligés du parcours, et trois d'entre eux cachent un piège d'initialisation.

La somme ne pose pas de problème : accumulateur à 0, puis somme ← somme + T[i].

La moyenne se calcule après la boucle, une seule fois : moyenne ← somme / n. Diviser à l'intérieur donnerait un résultat faux à chaque tour sauf le dernier.

Le minimum et le maximum sont le vrai piège. La tentation est d'écrire :

1max ← 0                          ← FAUX2Pour i de 0 à n − 1 Faire3    Si T[i] > max Alors max ← T[i] FinSi4FinPour

Sur [12, 5, 20, 8, 3], ça marche. Sur un tableau de températures hivernales [−3, −8, −5], le résultat est 0 — une température qui n'apparaît nulle part dans les données. Le maximum d'un tableau est forcément une valeur du tableau ; il faut donc partir de l'une d'elles :

1max ← T[0]2Pour i de 1 à n − 1 Faire3    Si T[i] > max Alors max ← T[i] FinSi4FinPour

Même raisonnement pour le minimum. Cette règle s'énonce simplement : on initialise avec la première valeur, jamais avec une constante inventée.

À vous

// Un seul parcours, quatre résultats.
// Consigne : écrivez la boucle sur les INDICES. Pas de reduce, pas de
// Math.min(...t) — c'est le parcours qu'on apprend ici, pas la bibliothèque.
const T = [12, -5, 20, 8, 3];

function analyser(t) {
  let somme = 0;
  let min = 0;   // ← initialisation piégée : corrigez-la
  let max = 0;   // ← celle-ci aussi

  for (let i = 0; i < t.length; i++) {
    // à compléter
  }

  return { somme, min, max, moyenne: somme / t.length };
}

console.log(analyser(T));
// attendu : { somme: 38, min: -5, max: 20, moyenne: 7.6 }

const T = [12, -5, 20, 8, 3];

function analyser(t) {
  let somme = 0;
  // On part de la PREMIÈRE VALEUR, jamais de 0 : avec un tableau de
  // températures négatives, un max initialisé à 0 ne serait jamais remplacé.
  let min = t[0];
  let max = t[0];

  for (let i = 0; i < t.length; i++) {
    somme = somme + t[i];
    if (t[i] < min) min = t[i];
    if (t[i] > max) max = t[i];
  }

  // La moyenne se calcule APRÈS la boucle, une seule fois.
  return { somme, min, max, moyenne: somme / t.length };
}

console.log(analyser(T));

À retenir