Licence CC BY-NC-SA

Les boucles

Publié :

Dans le chapitre précédent, nous avons vu comment réaliser des conditions et permettre ainsi aux machines de faire des choix. C'est déjà un grand pas dans le monde informatique mais ce n'est pas suffisant : à présent, nous allons introduire les boucles !

Les boucles sont liées à la notion de répétitivité : il s'agit en fait de réitérer une série d'instructions plusieurs fois. Les boucles sont indispensables dans tout un tas de situations, par exemple lorsque nous demandons à l'utilisateur de jouer tant que la partie n'est pas terminée. Pour cela nous disposons de trois boucles en Actionscript 3 que nous détaillerons au fil du chapitre. Étant donné que nous avons déjà vu comment écrire une condition, ce chapitre devrait être relativement simple à appréhender.

La boucle while

Le principe

Comme nous l'avons dit précédemment, les boucles permettent de répéter des instructions un certain nombre de fois. La difficulté est alors de savoir quand ces instructions doivent cesser d'être répétées. Pour cela, nous aurons besoin des conditions. Sans plus attendre, voici le genre d'instructions faisables à l'aide des boucles :

1
2
TANT QUE ma condition est vraie
ALORS effectuer mes instructions

Dans une boucle while, la condition s'utilise exactement de la même manière que pour une instruction if...else. Il faudra donc déclarer une variable avant la boucle puis la tester à l'intérieur de la condition. En revanche, dans ce cas la variable devra être mise à jour à l'intérieur de la boucle pour pouvoir en sortir. En effet, pour stopper la répétition des instructions, la condition doit obligatoirement devenir fausse à un certain moment. Oublier de mettre à jour cette variable conduirait à une boucle infinie, c'est-à-dire que les instructions se répèteraient à l'infini.

Dans le cas d'une boucle while, la condition est testée avant d'entrer dans la boucle. Ainsi si la condition est déjà fausse avant la boucle, les instructions à l'intérieur de celle-ci ne seront jamais exécutées.

Encore une fois, vous comprendrez mieux le fonctionnement des boucles au fur et à mesure de la lecture de ce chapitre.

Écriture en Actionscript

En Actionscript, la boucle while permet de gérer toutes les situations : celles que nous verrons plus tard sont légèrement différentes mais n'offrent aucune fonctionnalité supplémentaire. La structure d'une boucle est très similaire à celle des structures conditionnelles vues précédemment. Voici donc comment écrire une boucle while en Actionscript :

1
2
3
4
while(/* Condition */)
{
    // Instructions si vraie
}

Comme pour l'instruction if...else, les accolades deviennent facultatives s'il n'y a qu'une seule condition :

1
2
while(/* Condition */)
    // Instruction si vraie

Cette seconde syntaxe est correcte : en écrivant cela vous n'aurez pas de message d'erreur. Cependant dans une boucle digne d'intérêt, vous n'aurez en réalité que très rarement une seule instruction. En effet, votre boucle contiendra toujours au moins une instruction ainsi qu'une mise à jour de votre variable.

Afin de mieux comprendre le fonctionnement et la syntaxe d'une boucle while, nous allons voir différents exemples dans la suite.

Exemples d'utilisation

Pour commencer, nous allons tester une boucle qui affiche la valeur de notre variable testée dans la condition. Cet exemple permettra de mieux comprendre le fonctionnement d'une boucle. Voici le code source de notre boucle à tester :

1
2
3
4
5
6
var i:uint = 0;
while(i < 5)
{
    trace(i);
    i = i + 1;
}

Si vous lancez le projet, vous devriez obtenir ceci dans la console de sortie :

1
2
3
4
5
0
1
2
3
4

Vous constaterez alors que la valeur 5 n'est pas affichée. Effectivement, lorsque notre variable i prend cette valeur, la condition i < 5 n'est plus vérifiée ; l'instruction trace(i) n'est donc plus exécutée. Il faudra ainsi être vigilant sur l'écriture de votre condition pour que votre boucle s'exécute bien comme vous le désirez.

L'intérêt d'utiliser une boucle while est que nous n'avons pas besoin de connaître à l'avance ou de nous soucier du nombre de répétitions. Pour illustrer cela nous allons prendre un exemple : imaginons que nous cherchions la puissance de 2 correspondant à 1024. Nous devons alors calculer les puissances successives de 2 jusqu'à atteindre 1024. Cependant ici nous ne savons pas combien de fois nous allons devoir répéter l'opération. Nous utiliserons donc une boucle while de la manière suivante :

1
2
3
4
5
6
7
8
var monNombre:uint = 2;
var i:uint = 1;
while(monNombre != 1024)
{
    i = i + 1;
    monNombre *= 2;
}
trace(i); // Affiche : 10

En effet, pour ceux qui connaissaient déjà la réponse : $2^{10}=1024$. Notre boucle s'est donc exécutée 9 fois ce qui correspond à i = 10. Nous voyons bien ici que nous n'avions pas besoin de connaître à l'avance le nombre de répétitions de la boucle.

Quelques astuces

Vous savez déjà tout ce qu'il faut savoir sur la boucle while, cependant nous allons voir ici quelques astuces pour améliorer la lisibilité de votre code. Ces quelques conseils ne sont en aucun cas une obligation, il s'agit principalement de pratiques très courantes au sein des programmeurs. Ceci permettra d'alléger votre code source mais également de le rendre plus lisible pour un autre programmeur. Voici donc quelques astuces fortement recommandées :

  • traditionnellement en Actionscript et dans beaucoup d'autres langages, on utilise les noms de variables i, j et k pour compter à l'intérieur d'une boucle. En utilisant ces noms, vous facilitez la lecture de votre code, surtout si celui-ci est assez conséquent.
  • lorsque vous utiliserez des boucles, vous serez très souvent amené à incrémenter ou décrémenter vos variables : i = i + 1 ou i = i- 1. Pour simplifier l'écriture, nous pouvons utiliser pour l'incrémentation i++ et pour la décrémentation i--.

Enfin pour finir, nous allons revenir sur la notion de boucle infinie. Comme nous l'avons dit, il s'agit d'une boucle dont la condition est toujours vérifiée. Les instructions à l'intérieur sont alors répétées à l'infini. En voici un exemple :

1
2
3
4
5
var maCondition:Boolean = true;
while(maCondition)
{
    trace("Ceci est une boucle infinie");
}

Vous vous en doutez certainement, cette boucle va afficher le message : « Ceci est une boucle infinie » un nombre indéfini de fois, comme ceci :

1
2
3
4
Ceci est une boucle infinie
Ceci est une boucle infinie
Ceci est une boucle infinie
...

En général, il faut à tout prix éviter d'écrire ce genre de choses. Cependant ce type de boucles peut s'avérer utile dans certains cas.

La boucle do...while

Nous allons à présent parler de la boucle do...while, qui est une voisine très proche de la boucle while. Toutefois nous pouvons noter une différence dans la syntaxe par l'apparition du mot do ainsi que du transfert de la condition en fin de boucle. Ceci apporte une légère différence dans l'interprétation du code mais nous y reviendrons après. Voici la syntaxe de cette nouvelle boucle :

1
2
3
4
do
{
    // Instructions si vraie
} while(/* Condition */);

Notez l'apparition d'un point-virgule « ; » après la condition.

Quelle est la différence avec la boucle précédente ?

Dans une boucle while classique, la condition est en début de boucle. C'est pourquoi la boucle peut ne jamais être exécutée si la condition est fausse dès le départ. En revanche dans une boucle do...while, la condition est placée à la fin de la boucle. De ce fait, la boucle s'exécutera toujours au moins une fois. Il est donc possible d'utiliser cette boucle pour s'assurer que le programme rentrera au moins une fois dans la boucle. Voici un exemple de calcul de PGCD :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
var nombre1:uint = 556;
var nombre2:uint = 148;
var reste:uint;
do
{
    reste = nombre1 % nombre2;
    nombre1 = nombre2;
    nombre2 = reste;
} while(nombre2 != 0);
trace("PGCD = " + nombre1); // Affiche : PGCD = 4

Petit rappel : PGCD pour Plus Grand Commun Diviseur. Si vous ne vous souvenez plus de l’algorithme, il faut diviser le plus grand nombre par le plus petit. Ensuite on prend le reste de la division euclidienne pour diviser le nombre le plus petit. Puis on reprend le dernier reste pour diviser le reste de la division précédente. Et ainsi de suite jusqu'à ce qu'un reste soit nul. Vous avez ainsi votre PGCD qui correspond au dernier reste non nul !

Encore ici, vous pouvez remarquer qu'il n'est pas nécessaire de connaître le nombre d'exécutions de la boucle contrairement à une boucle for dont nous allons parler maintenant.

La boucle for

Présentation

La syntaxe

Comme nous l'avons déjà dit, la boucle while permet de réaliser toute sorte de boucle. Cependant son écriture est quelque peu fastidieuse, c'est pourquoi il existe une écriture condensée utile dans certains cas : la boucle for. Celle-ci est utilisée lorsque nous connaissons à l'avance le nombre d'exécutions de la boucle, soit directement soit à travers une variable. Cette boucle permet de concentrer le traitement de la variable utilisée, rappelez-vous avec une boucle while, nous devions passer par les étapes suivantes :

  • déclaration et initialisation de la variable avant la boucle
  • condition sur la variable en entrée de boucle
  • incrémentation de la variable à l'intérieur de la boucle.

Grâce à la boucle for, nous pouvons maintenant condenser ces trois étapes au même endroit :

1
2
3
4
for(/* Initialisation */; /* Condition */; /* Incrémentation */)
{
    // Instructions
}

Attention là encore à la présence des points-virgules « ; » pour séparer chaque champ. C'est également une source de problèmes pour la compilation.

Quelques exemples

La boucle for est très utilisée en programmation, elle permet d'éviter d'avoir à écrire des instructions répétitives mais permet également de faire des recherches dans les tableaux que nous aborderons très bientôt. En attendant, voici quelques exemples d'utilisation de la boucle for :

1
2
3
4
for(var i:int = 0; i < 10; i++)
{
    trace("La valeur de i est " + i);
}

Ici également, les accolades deviennent facultatives s'il n'y a qu'une seule instruction. Aussi il est possible d'utiliser la boucle for en décrémentation ou en encore par pas de 10 si vous le désirez :

1
2
for(var i:int = 10; i > 0; i--)
    trace("La valeur de i est " + i);

La boucle for n'a rien de difficile, il s'agit simplement d'une boucle while condensée. En revanche la syntaxe est assez spéciale, c'est pourquoi il est nécessaire de la retenir car cette boucle vous servira plus que vous ne l'imaginez ! :lol:


En résumé

  • Les boucles permettent de répéter une série d'instructions tant qu'une condition est vérifiée.
  • La boucle while permet de tout faire mais il est possible que les instructions à l'intérieur ne soient jamais exécutées.
  • La boucle do...while est identique à la précédente, néanmoins la boucle est exécutée au moins une fois.
  • La boucle for est une forme condensée du while dans le cas où on connaît le nombre de répétitions de la boucle.
  • L'incrémentation est utilisée en permanence dans les boucles et son écriture peut être simplifiée par les expressions « i++ » et « i-- ».