LES STRUCTURES DE CONTRÔLE (2)

Les instructions de boucle

- La structure for (...) ... qui permet de répéter une séquence tout en faisant progresser la valeur d'une variable.
- La strucure while (...) qui répète l'exécution d'instruction tant que (while) une condition sera remplie.
- La strucure do ... while(..) qui fait la même chose que le while sauf que la condition n'est vérifiée qu'après le passage dans la boucle. // permet de passer au moins une fois dans la boucle.


L'instruction FOR

C'est l'instruction de boucle qui est certainement la plus utilisée.
sa forme générale est :
for (expression initaile; condition de répétition;progression)
{
bloc d'instructions à: répéter.
}
Très souvent l'expression initiale est un compteur.
par exemple, si on veut faire la somme des 20 premiers nombres on fera :
var valeur_final;
for (var i=1;i<=20;i++) {
valeur_final+=i;
}
document.write("La somme des 20 premiers entiers vaut :"+somme_final);
Soit uen somme finale de 210.
On pourrais faire de même avec une factorielle! (20*19*18*17*......).
Une remarque, la valeur du compteur est accessible endehors de la boucle, c'est à dire qu'une fois la boucle finie i vaudra 20.

On peut très bien imbriquer des structures de contrôle entre elles :
var valeur_final;
for (var i=1;i<=20;i++) {
  if (i!=15) {
  valeur_final+=i;
  }
}
document.write("La somme des 20 premiers entiers sans le 15 vaut :"+somme_final);

Mais cette exemple peut s'écrire plus simplement avec une instruction continue :
var valeur_final;
for (var i=1;i<=20;i++) {
  if (i==15) continue;
  valeur_final+=i;
}
document.write("La somme des 20 premiers entiers sans le 15 vaut :"+somme_final);

Le continue permet de "sauter" le reste des instructions de la boucle, et de repartir pour un nouveau tour.
De même l'instruction break; permet d'arrêter la boucle :
var valeur_final;
for (i=0;i<20;i++) {
somme_final+=i;
if (i==15) break;
}

Là on obtiendrait la somme des entiers de 1 à 15, soit 120 !

L'instruction WHILE

La forme générale de l'instruction est :
while(condition) // tant que la condition est vérifié faire.
{
bloc d'instructions
}

Dans le cas du while, on vérifie en premier la condition et si elle est true, alors on exécute le bloc d'instructions.
Il ne faut pas oublier que la condition de boucle doit évoluer! Pour cela il est logique qu'elle dépende d'au moins une des variables contenue dans le bloc d'instructions.
Ou alors il faut utiliser une autre structure de contrôle avec l'instruction break;.
L'instruction continue permet, comme dans l'instruction for.
En prenant comme exemple :
var compteur =0;
var somme_final;
while (compteur<20) {
compteur++;
  if (compteur==15) continue;
  if (compteur==17) break;
somme_final += compteur;
}

J'applique exactement ce que je viens de dire, si je n'avais pas le break,
le while continuerait jusqu'a ce que compteur=20 en sautant le compteur==15.
Avec le break il s'arrête à 17.
Dans cet exemple, j'aurais somme_final=121 soit la somme des entiers jusqu'à 14 plus 16,
car le somme_final+=compteur; est placé après le break;.
Mais il n'est pas forcément besoin de faire compteur++ à l'intérieur du while :
var compteur =0;
var somme_final;
while (compteur++<20) {
  if (compteur==15) continue;
  if (compteur==17) break;
somme_final += compteur;
}

(Pour rappel, while(compteur++<20) teste compteur par rapport à 20 et ensuite lui rajoute 1,
alors que while(++compteur<20) ajoute 1 à compteur et ensuite le teste par rapport à 20.)

L'instruction DO ...WHILE

La forme générale de l'instruction est :
do
{
bloc d'instructions
} while(condition) // tant que la condition est vérifié faire.

Quasiment identique au while, sauf au fait qu'on passe forcément dans la boucle au moins une fois,
puisque la condition est testée après le passage.
Les instructions break; et continue marchent élement là.
Pour l'instruction break; il existe une structure de contrôle par étiquettes,
mais pour le moment je ne pense pas qu'il soit besoin de le voir ;-)


< précédent