Les boucles while en R : while, repeat et break expliqués

La boucle while

Une boucle while en R continue d'exécuter son corps tant qu'une condition reste TRUE. Là où une boucle for s'exécute une fois par élément de quelque chose, while s'exécute un nombre inconnu de fois - jusqu'à ce qu'une condition change :

count <- 1

while (count <= 5) {
  print(count)
  count <- count + 1
}

Trois parties font fonctionner chaque boucle while, et les trois sont visibles ici :

1. L'initialisation avant la boucle - count <- 1 donne à la condition quelque chose à tester.
2. La condition - count <= 5, construite avec les opérateurs de comparaison habituels, vérifiée avant chaque passage.
3. La mise à jour dans le corps - count <- count + 1 fait avancer la boucle vers son arrêt.

Supprime la partie 3 et la condition est TRUE pour toujours : la boucle ne se termine jamais. C'est le risque caractéristique de while, et le reste de cette page consiste largement à le gérer.

La condition est vérifiée avant chaque passage

while teste sa condition d'abord, puis exécute le corps. Deux conséquences en découlent. Si la condition est déjà FALSE au départ, le corps s'exécute zéro fois :

stock <- 0

while (stock > 0) {
  print("selling one item")
  stock <- stock - 1
}

print("loop finished without running")

Et le test a lieu entre deux passages complets, pas en cours de corps - une fois qu'un passage a commencé, il va jusqu'au bout même si la condition devient FALSE en cours de route. Si tu dois sortir en plein corps, c'est à ça que sert break (ci-dessous).

Un exemple traité : diviser par deux jusqu'à passer sous un seuil

Le terrain naturel de while, c'est « continue jusqu'à » : tu ne peux pas savoir à l'avance combien de passages il faudra, donc for ne convient pas. Combien de fois peux-tu diviser 1000 par deux avant qu'il passe sous 1 ?

value <- 1000
steps <- 0

while (value >= 1) {
  value <- value / 2
  steps <- steps + 1
}

print(steps)
cat("final value:", value, "\n")

Dix divisions, se terminant vers 0,977. Ce motif - une variable d'état que le corps réduit, un compteur qu'il augmente - couvre une énorme part des vraies boucles while : méthodes numériques qui tournent jusqu'à ce que l'erreur soit assez petite, simulations qui tournent jusqu'à épuisement d'une ressource, nouvelles tentatives qui continuent jusqu'à ce qu'un appel réussisse.

repeat + break : le do-while de R

R n'a pas de mot-clé do-while - pas de boucle qui teste sa condition après le corps. Mais il a repeat, qui boucle indéfiniment sans condition, et break, qui sort immédiatement de n'importe quelle boucle. Mets le test de break à la fin d'un corps de repeat et tu as construit exactement un do-while - une boucle dont le corps est garanti de s'exécuter au moins une fois :

n <- 1

repeat {
  n <- n * 2
  if (n > 100) break
}

print(n)

Le corps s'exécute toujours avant le premier test, donc n est doublé au moins une fois ; la boucle sort à 128, le premier doublement au-delà de 100. Utilise cette forme quand « fais la chose, puis décide s'il faut la refaire » est la description honnête - lire une saisie jusqu'à ce qu'elle soit valide, tirer des échantillons jusqu'à en obtenir un qui convient. Un repeat sans break atteignable est une boucle infinie par construction, alors écris le break en premier, puis remplis le corps.

break fonctionne à l'identique dans les boucles while et for - c'est la sortie générale « on a fini ici », et elle s'associe naturellement aux instructions if qui testent une condition en cours de corps.

next dans une boucle while

next saute le reste du passage courant et revient au test de la condition. Il fonctionne dans while comme dans for - avec un piège propre à while : si l'étape de mise à jour vient après le next, la sauter signifie que la variable de boucle n'avance jamais, et tu as construit une boucle infinie. Mets la mise à jour avant le next :

i <- 0

while (i < 10) {
  i <- i + 1          # update FIRST...
  if (i %% 2 != 0) next  # ...then it's safe to skip odd numbers
  print(i)
}

Ça affiche les nombres pairs de 2 à 10. Déplace i <- i + 1 sous la ligne next et la première valeur impaire sauterait la mise à jour pour toujours. Dans les boucles for, ce danger n'existe pas (la variable de boucle avance automatiquement), une raison de plus de préférer for quand tu ne fais que parcourir une séquence.

Se prémunir des boucles infinies

Toute boucle infinie est le même bug : rien dans le corps ne modifie les variables dont dépend la condition - ou les modifie dans le mauvais sens. En interactif tu peux interrompre avec Échap ou Ctrl+C, mais dans un script le processus se contente de rester bloqué. Deux habitudes l'évitent.

D'abord, quand tu écris la condition, demande-toi immédiatement « quelle ligne du corps la fait tendre vers FALSE ? » et assure-toi que cette ligne s'exécute sur tous les chemins à travers le corps (attention au piège du next ci-dessus).

Ensuite, pour les boucles dont tu ne peux pas prouver facilement la terminaison, ajoute un garde-fou sur le nombre maximal d'itérations pour qu'un bug de logique produise un résultat diagnosticable plutôt qu'une session figée. Ici il protège une boucle de type Collatz - diviser par deux les nombres pairs et transformer un x impair en 3 * x + 1, jusqu'à atteindre 1 :

x <- 10
steps <- 0

while (x != 1 && steps < 10000) {
  if (x %% 2 == 0) x <- x / 2 else x <- 3 * x + 1
  steps <- steps + 1
}

cat("reached", x, "after", steps, "steps\n")

En partant de 10, la boucle atteint 1 en 6 étapes. Si une valeur de départ n'atteignait jamais 1, la clause steps < 10000 mettrait quand même fin à la boucle, et l'état affiché te dirait que quelque chose a mal tourné - une mauvaise réponse que tu peux voir vaut mieux qu'un programme qui ne répond jamais. Le && à court-circuit est le bon opérateur ici : les deux côtés sont des valeurs uniques, et le garde-fou se lit comme une seule phrase.

while ou for : choisir

La règle empirique porte sur ce que tu sais à l'avance :

• Tu sais sur quoi tu itères (éléments d'un vecteur, nombres de 1 à n) : utilise une boucle for - la variable de boucle se gère toute seule.
• Tu ne connais que la condition d'arrêt (jusqu'à convergence, jusqu'à passer sous un seuil, jusqu'à validité) : utilise while.
• Le corps doit s'exécuter au moins une fois avant que tout test ait un sens : utilise repeat avec un break terminal.

Si tu te surprends à gérer un compteur manuel dans une boucle while juste pour parcourir un vecteur, c'est une boucle for déguisée - change.

Ce que tu retiens

• while (condition) { ... } teste d'abord, puis exécute - une condition fausse au départ signifie zéro passage.
• Le corps doit faire tendre la condition vers FALSE ; le trio initialisation / condition / mise à jour, c'est toute la discipline.
• R n'a pas de mot-clé do-while : repeat { corps; if (fini) break } est l'idiome, garantissant au moins un passage.
• break sort de n'importe quelle boucle ; avec next dans un while, mets à jour la variable de boucle avant le saut, sinon elle n'avance jamais.
• Un garde-fou sur le nombre d'itérations (&& steps < 10000) transforme un blocage potentiel en une mauvaise réponse visible et débogable.

Prochaine étape : les vecteurs - la structure de données que chaque boucle de cette page parcourait, et la raison pour laquelle beaucoup de boucles R peuvent disparaître complètement.