|
boucle FOR |
  copyleftSee You Why? |
Nous avons déjà rencontré des boucles involontaires en abordant les fonctions qui peuvent s'appeler l'une l'autre. Approche souvent non souhaitée du serpent qui se mange la queue.
Dans les langages informatiques, il est cependant souvent fait appel aux boucles. Mais qu'est-ce qu'une boucle ? En informatique, on dira qu'elles permettent de répéter une séquence du programme un nombre spécifique et controlé de fois.
En JS, quelques méthodes de création de boucles sont utilisées fréquemment : avec les instructions FOR abordées dans ce chapitre et particulièrement utilisées lorsqu'on sait d'avance le nombre de fois que la liste des instructions doit être exécutée, les instructions WHILE abordées dans le chapitre suivant et les autres DO WHILE, etc.
La syntaxe de la boucle FOR est :
for (i=1; i<=10; i++){
document.write("Ligne " + i + "<br>" + i + " dont le carré est " + i*i ="<br>");
}
La liste des instructions à exécuter est notée entre les accolades (avec un point-virgule entre chaque instruction, c'est habituel). [Ces accolades ne sont pas indispensables s'il n'y a qu'une seule instruction, mais nous conseillons de les noter même dans ce cas.]
La boucle FOR nécessite donc trois paramètres séparés par des points-virgules (et pas des virgules, ce qui est inhabituel) :
i=1;i<=10;i++.L'exemple ci-dessus pourrait se lire :
Cet exemple définit une boucle for qui commence par i = 1. La boucle FOR continuera à fonctionner tant que i est inférieur ou égale à 10, qu'on augmenterait de 1 chaque fois que la boucle a été parcourue une nouvelle fois, et donc la boucle FOR va s’exécuter 10 fois.
Notes :
Le paramètre d'incrément pourrait être différent de 1, et également être négatif ;
et le <= pourrait être n'importe quel autre opérateur de comparaison.
Cette curieuse écriture pourrait en étonner plus d'un. L'usage des boucles est très fréquent et employé dans divers langages informatiques, avec une syntaxe légèrement différente... mais tous notent les 3 éléments sur une même ligne de code : valeur de départ de la variable compteur, condition et incrémentation. Tout programmeur qui se respecte doit maîtriser cette boucle.
Nous aborderons aussi la boucle FOR... IN... qui permet de boucler à travers tous les éléments d'un objet, comme par exemple les propriétés d'un élément ou les valeurs d'un tableau.
Nous lui avons donné comme nom i, et ce n'est pas un hasard : depuis les débuts de l'informatique, et dans quasi tous les langages informatiques, la lettre i est considérée comme la variable de compteur.
Rien ne vous empêche d'employer un autre nom de variable, mais vous vous écarterez des habitudes informatiques...
Nous avons initialisé sa valeur à 1, pour compter plus facilement le nombre de fois que la boucle sera exécutée... Nombreux sont les informaticiens qui commencent à 0 ; en effet, les ordinateurs démarrent toujours avec le plus petit entier, qui n'est pas 1, mais 0. À vous de choisir à l'avenir.
Si plusieurs variables compteurs sont nécessaires, on emploiera successivement i, j, k, etc. C'est une convention de programmation. Ce sera le cas si on fait usage de boucles imbriquées.
La condition de poursuite de la boucle est parfois appelée à tort, condition d'arrêt de la boucle... Puisque nous souhaitons voir la boucle s'exécuter 10 fois, une condition d'arrêt serait que i soit supérieur à 10... or la boucle doit se poursuivre tant que i est inférieur ou égal à 10.
i<=10 est la condition qui décide si la boucle continue à s'exécuter ou non. Cette vérification comprend généralement la variable compteur d'une certaine façon... mais il est possible que la condition soit d'une autre nature.
Le bouclage va continuer jusqu’à ce que i devienne égal à 11, ce qui n'est plus inférieur ni égal à 10, conduisant ainsi le code de la boucle à cesser l'exécution. Veiller à ce que la valeur initiale de la variable compteur permette au moins une fois l'exécution du code... sinon votre boucle est inutile.
La valeur initiale du compteur et la condition de poursuite permettent une première exécution du code de la boucle. Après cette exécution, la variable compteur s'incrémente (généralement de 1). Cette incrémentation se note i++ qui ne signifie rien d'autre que i=i+1, c-à-d que la nouvelle valeur de i est l'ancienne augmentée de 1.
Après cette incrémentation, JS va exécuter la boucle puis JS va vérifier si la condition i<=10 est toujours remplie et si oui, un nouveau passage dans le code de la boucle se fera... ainsi de suite, jusqu'au moment ou la condition, après incrémentation, n'est plus remplie.
Nous pourrions aussi avoir une décrémentation : i-- qui ne signifie rien d'autre que i=i-1, c-à-d que la nouvelle valeur de i est l'ancienne diminuée de 1. Et rien n'empêche d'avoir d'autres incrémentations et/ou décrémentations, même si les deux mentionnées ci-avant sont les plus fréquentes. On pourrait avoir i=i+10, c-à-d que la nouvelle valeur de i est l'ancienne augmentée de 10, ou i=i-97, c-à-d que la nouvelle valeur de i est l'ancienne diminuée de 97... mais quel en est l'avantage ?
Rappelons donc :
for (i=1; i<=10; i++){
// liste d'instructions terminées par ;
}
ou
for (variable_compteur=valeur_initiale; condition de poursuite; incrémentation){
// liste d'instructions terminées par ;
}
Il s'agit dès lors de bien connaitre le nombre de fois que sera exécutée la boucle :
Rappelons donc que dans la boucle suivante :
for (i=1; i<=10; i++){
// liste d'instructions terminées par ;
}
au premier passage, i étant initialisé à 1, la variable compteur vaut évidemment 1,
elle est bien inférieure ou égale à 10, donc la condition est vérifiée,
elle sera augmentée de 1 après le premier passage dans la boucle;
à la fin de son premier passage dans la boucle,
la variable compteur prend donc la valeur 2 (son ancienne valeur incrémentée de 1),
elle vaut 2 et est bien inférieure ou égale à 10, donc la condition est vérifiée,
elle sera augmentée de 1 après ce deuxième passage dans la boucle;
etc.
à la fin de son neuvième passage dans la boucle,
la variable compteur i est incrémentée de 1 et prend la valeur 10,
elle vaut donc 10 et est bien inférieure ou égale à 10, donc la condition est toujours vérifiée,
elle sera augmentée de 1 après le premier passage dans la boucle;
à la fin de son dixième passage dans la boucle,
la variable compteur i est incrémentée de 1 et prend la valeur 11,
elle vaut donc 11 et n'est plus inférieure ou égale à 10,
donc la condition n'est plus vérifiée,
la boucle s'interrompt et le programme se poursuit à la ligne qui suit le crochet fermant de la boucle;
Nous croyons utile de rappeler ici quelques conseils particuliers :
aioli dans notre exemple ;Un exemple de code qui ne respecte pas ces conseils :
var pizzaiolo,aioli,alio="",aolio,ailoa,aile=" ",elio="<br>"; for(aioli=1;aioli<=15;aioli++) { aolio=aioli*aioli; ailoa=aolio*aioli; pizzaiolo=aioli; pizzaiolo=pizzaiolo+2;
aioli=pizzaiolo-2; alio=alio+aioli+aile+aolio+aile+ailoa+elio;}
document.write(alio);
Vous avez compris ? Non ? Et pourtant il marche... cependant, voici le même code qui suit ces conseils :
var i,affiche="",carre,cube,esp=" ",nl="<br>";
for (i=1;i<=15;i++) {
carre=i*i;
cube=carre*i;
affiche=affiche+i+esp+carre+esp+cube+nl;
}
document.write(affiche);
Tout le monde comprendra que c'est une boucle parcourue 15 fois et qui donne le carré et le cube des 15 premiers entiers positifs... et pour preuve
Exemple
|
voir suite >>>
voir suite >>>
voir suite >>>