La boucle for permet de répéter du code un certain nombre de fois. Mais ce nombre de répétition doit obligatoirement être connu au moment où l'on commence la boucle, lorsqu'on précise la valeur initiale et la valeur finale du compteur. Après cela, il n'y a plus aucun moyen d'interrompre la boucle, c'est-à-dire de l'arrêter avant que le compteur soit arrivé à sa valeur finale.

Il existe donc une autre boucle, la boucle while qui permet de contrôler comme on veut le nombre d'exécution. En effet, avant chaque exécution du corps de cette boucle, on peut choisir si on veut exécuter ce corps de la boucle ou bien si préfère s'arrêter et passer à la suite. Concrètement, la boucle s'effectue tant qu'une certaine condition est réalisée, c'est-à-dire est évaluée comme vraie.

while (...condition...) do
  (...corps de la boucle while...)
done;

Explications :

• Le mot clé while se traduit tant que.
• La condition est une expression booléenne.
• Le corps d'une boucle while est analogue au corps d'une boucle for. En particulier, une déclaration effectuée à l'intérieur du corps d'une boucle
a une portée limitée à ce corps.

Remarque sur les extrêmes :

• Si la condition est fausse la première fois qu'on l'évalue,
le corps de la boucle ne sera pas exécuté du tout.
• Si la condition est toujours vraie, alors le programme ne s'arrêtera pas.
On appelle cela une boucle infinie.

Comment la condition peut-elle être vraie au début, et devenir faux au bout d'un certain moment ? Il y a deux possibilités, on va donc donner deux exemples.

La première possibilité est que la condition dépende d'une valeur donnée par l'utilisateur. Le programme que l'on va étudier simule un coffre fort. Ce programme demande à l'utilisateur un entier. Si cette combinaison est le code secret, alors le coffre s'ouvre, mais sinon, le programme indique à l'utilisateur qu'il s'est trompé et qu'il doit recommencer.

Au début, le programme attend que l'utilisateur tape un nombre. Lorsque le bon code est trouvé, il affiche "Coffre ouvert !". A chaque fois que l'utilisateur se trompe, il affiche "Code non valide !", puis recommence depuis le début. Dans cet exemple, le code secret est 36. La condition de la boucle s'exprime donc par l'expression (read_int() <> 36). Si l'utilisateur donne 36, cette expression est fausse et la boucle s'arrête. Dans les autres cas, cette expression est vraie, et le coffre reste fermé et le programme recommence.

while read_int() <> 36 do
  print_string "Code non valide !\n";
done;
print_string "Coffre ouvert !\n";

La seconde possibilité pour que la condition de la boucle change au bout d'un moment est que cette condition dépende de la valeur d'une référence. Dans ce cas, la référence peut être modifiée dans le corps de la boucle.

L'exemple suivant initialise une référence i à 0, et tant que le contenu de i est inférieur à 20, le corps de la boucle se chargera d'afficher ce contenu, puis de l'augmenter de 1 (c'est-à-dire incrémenter i). Voici le code :

let i = ref 0 in
while !i <= 20 do
  print_int !i;
  print_string " ";
  incr i;
done;
print_string "c'est fini";

Remarque : on pourrait remplacer while !i <= 20 do par while !i <> 20 do puisqu'on sait que comme les valeurs de !i augmentent, !i finira par atteindre 20. On va comprendre dans l'exercice suivant pourquoi il ne faut pas le faire.