while

Les boucles "TANT QUE"

Une boucle sert à répéter une action. Rappelons brièvement la principale différence entre une boucle "pour" et une boucle "tant que" :

Avec une boucle "pour", on connaît à l'avance le nombre de répétitions de l'action à exécuter.
Avec une boucle "tant que", le nombre de répétitions est conditionné par l'évolution de l'état de certaines variables du programme.

Un premier exemple : la table de multiplication du 8.

Cet exemple a été vu avec la boucle for. La comparaison des deux devrait vous aider à comprendre les différences entre ces deux types de boucle.

		 
		k=1
		Tant que k < 11 :
		    afficher k*8
		    incrémenter k d'une unité
		fin_tantque

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="utf-8">
        <title> Table du 8 </title>
    </head>
    <body>
        <script>
        let i = 1;
        while( i < 11 ) {
            document.write(`8 × ${i} = ${8*i} <br>`);
            i += 1;
        }
        </script>
    </body>
</html>

Tout programme pouvant s'écrire avec une boucle for peut également s'écrire avec une boucle while.

JavaScript propose en fait deux boucles while. La précédente effectue le test avant de rentrer dans la boucle. Mais on peut aussi l'effectuer en sortie de boucle.

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="utf-8">
        <title> Table du 8 </title>
    </head>
    <body>
        <script>
        let i = 1;
        do {
             document.write(`8 × ${i} = ${8*i} <br>`);
             i += 1;
        } while ( i < 11);
        </script>
    </body>
</html>

Pour cet exemple, l'utilisation de l'une ou l'autre des boucles while est indifférente. Dans certains cas, l'utilisation de l'une des deux formes plutôt que l'autre pourra allèger un peu le code du script.

Une différence entre les deux boucles : le corps de la boucle est toujours exécuté au moins une fois avec do {} while (); alors qu'il peut ne jamais être exécuté avec while () {} du fait de la position du test.

Un second exemple : dépasser une borne par additions

Déterminer le plus petit entier naturel n tel que la somme S=1+2+3+...+n soit strictement supérieure à 10 000.

Cet exemple est une situation pour laquelle une boucle while est plus appropriée qu'une boucle for. On ne sait pas à l'avance combien d'entiers il faudra ajouter pour dépasser une certaine valeur : on ne peut donc pas a priori utiliser une boucle for.

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="utf-8">
        <title> Dépasser une borne </title>
    </head>
    <body>
        <script>
        let borneSuperieure = 10000; // valeur à dépasser
        let i = 0; // contiendra les entiers naturels successifs
        let somme = 0; // contiendra les sommes d'entiers successifs
        while ( somme <= borneSuperieure ) {
            i += 1;
            somme += i;
        }
        document.write(`La somme des entiers de 1 à  ${i-1} est égale à ${somme-i}. <br>`); 
        document.write(`La somme des entiers de 1 à ${i} est égale à ${somme}. <br>`);
        document.write(`L'entier demandé est donc ${i}.`);
        </script>
    </body>
</html>

Avec la forme do ... while :

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="utf-8">
        <title> Dépasser une borne </title>
    </head>
    <body>
        <script>
        let borneSuperieure = 10000; // valeur à dépasser
        let i = 0; // contiendra les entiers naturels successifs
        let somme = 0; // contiendra les sommes d'entiers successifs
        do  {
            i += 1;
            somme += i;
        } while ( somme <= borneSuperieure );
        document.write(`La somme des entiers de 1 à  ${i-1} est égale à ${somme-i}. <br>`); 
        document.write(`La somme des entiers de 1 à ${i} est égale à ${somme}. <br>`);
        document.write(`L'entier demandé est donc ${i}.`);
        </script>
    </body>
</html>