Les boucles.

La première boucle que nous allons voir dans ce chapitre est la boucle Do: LpWhile.
Mais tout d'abord, qu'est-ce qu'une boucle, me direz-vous ?
Une boucle est, comme son nom l'indique, une série d'instructions qui sera répétée en boucle tant qu'une ou plusieurs conditions ne sont remplies.

L'emplacement des boucles sur la calto

Tout au long de ce chapitre sur les boucles, vous allez découvrir de nouvelles fonctions. Pour éviter de vous indiquer à chaque fois leur emplacement, je vous indique ici, en début de chapitre, leur emplacement général. Vous vous rappelez de l'onglet COM ? Eh bien il va encore nous servir, car toutes les boucles se trouvent dedans.

• Do : SHIFT / PRGM / F1 / F6 / F6 / F3
• LpWhile : SHIFT / PRGM / F1 / F6 / F6 / F4
• While : SHIFT / PRGM / F1 / F6 / F6 / F1
• WhileEnd : SHIFT/ PRGM/ F1 / F6 / F6 / F2
• For : SHIFT / PRGM / F1 / F6 / F1
• To : SHIFT / PRGM / F1 / F6 / F2
• Step : SHIFT / PRGM / F1 / F6 / F3
• Next : SHIFT / PRGM / F1 / F6 / F4

Revenons-en à nos moutons

Entrons maintenant dans le vif du sujet. Comme je vous l'ai dit un peu plus haut, la première boucle que nous allons voir est la boucle Do:LpWhile.
La syntaxe sera la suivante :
Code : Autre


Je vais maintenant expliquer un peu plus en détail ce bout de code. Comme un bon exemple vaut toujours mieux qu'un long discours :
Code : Autre

Essayez de comprendre ce code par vous-mêmes, combien de fois sera affiché le message "TEST BOUCLES" ?
Secret (cliquez pour afficher)
Vous êtes tombés dans le piège ? C'est que vous n'avez pas lu attentivement le code ci-dessus. Bon : je vais expliquer quand même.
Code : Autre
Tout d'abord on initialise la variable A à 1.
Code : Autre
Ensuite on initialise (j'aime bien ce mot )la boucle.
Code : Autre
1ère instruction : TEST BOUCLES : c'est le texte qui s'affichera en boucle tant que la condition ne sera pas respectée.
Code : Autre
2ème instruction : sur cette ligne, on demande à la calculatrice d'ajouter 1 à la valeur de A tant que la condition n'est pas remplie. Ainsi, au premier passage de la boucle, la variable A vaudra 2 (1+1), puis au deuxième, elle vaudra 3 (2+1), et ainsi de suite.
Code : Autre
La boucle se terminera lorsque la condition sera remplie, à savoir lorsque la variable A sera inférieure à 5, et non pas égale à 5. Et je pense que ce fut la raison de votre erreur, si erreur il y eut.

Vous devez impérativement comprendre ce bout de code parfaitement. N'hésitez pas à créer vos propres boucles pour bien comprendre.

Tiens, j'allais oublier. Vous vous souvenez de la fonction Getkey ? Elle peut déjà nous servir ici. Par exemple, pour attendre que l'utilisateur appuie sur une touche pour continuer.
Exemple : vous voulez que le suite du programme s'affiche seulement si l'on appuie au préalable sur la touche EXE. C'est tout à fait possible ! Regardez ce bout de code :

Code : Autre


Eh bien non. Car si l'on réfléchit, que veut-on voir se répèter en boucle ? Oui, rien ! La calculette ne doit rien faire tant que l'on a pas appuyé sur la touche voulue. Examinez la dernière ligne, si l'on traduit cela donnerait : "Continuer la boucle tant que la valeur de la touche pressée n'est pas égale à 31". Or, la valeur 31 est assignée à la touche EXE, cela revient donc à dire "Continuer la boucle tant que la touche EXE n'a pas été pressée.
En résumé, on pourrait dire que la calculette va continuer à "ne rien faire" tant que l'on aura pas appuyé sur EXE.

Un petit exercice pour vous entraîner : écrivez un texte bidon, puis demandez à l'utilisateur d'appuyer sur EXE pour continuer le programme.

Secret (cliquez pour afficher)
Vous remarquerez que j'ai mis des : . Ils permettent de séparer deux instructions. C'est exactement comme la flèche, lorsque l'on appuie sur EXE, mais ça permet de gagner de la place. Mais je vous conseille de n'utiliser les : que pour ce genre de cas-là.

La boucle While / Wend (comprenez While / While End) est quasiment identique à la précédente. Ainsi, je n'aurai pas grand chose à rajouter. La syntaxe n'est par contre pas tout à fait la même, car ici, la condition sera exprimée en début de boucle (alors que, rappelez-vous, avec la boucle précédente, elle était à la fin). Voici donc la syntaxe à respecter :

While condition(s) à respecter
Instruction(s)
WhileEnd



Eh bien tout simplement parce qu'elles ne sont pas si identiques que ça. Vous l'aurez peut-être remarqué, mais la seconde boucle présente une différence notoire par rapport à la première. Dans le cas d'une boucle Do/LpWhile, la boucle sera toujours lue au moins une fois, alors que dans le cas d'une boucle Whle/WEnd, si la condition est déjà remplie dès le départ, la calto (abréviation de calculatrice ) sautera la boucle.

Cette boucle inclue en elle-même un compteur, ce qui est très utile lorsque vous voulez faire marcher les fonctions à l'intérieur de la boucle un cetain nombre de fois. Et puis il est simple à utiliser. Mais bon, si vous m'écoutez, tout est très simple ; c'est vrai qu'une fois compris, c'est toujours simple ...

For, To, Next

Cette fonction demande une petite chose : une variable, et c'est tout.
Comme d'habitude, la syntaxe :

For la valeur de départ que vous donnez à la variable, To la valeur d'arrivée de la variable
les fonctions à éxécuter
Next

Le chemin d'accès des fonctions For, To et Next est : SHIFT \ PRGM \ F1 \ COM \ F6 .
Toutes les fonctions sont là : For , To, Step (une fonction que nous verrons à la fin de cette partie), et Next.

Je reconnais que comme ça, ça ne parait pas évident ; mais un petit exemple vous aidera à mieux comprendre : imaginez que vous ayez copier sur votre voisin, et que vous ayez eu comme punition à copier 10 fois "Je ne dois pas tricher". Eh bien à la calculatrice, ce serait un jeu d'enfant :
Code : Autre

Alors, les explications :

• la variable A prend comme valeur de départ 1 (For 1->A), et devra s'arrêter lorsqu'elle aura atteint la valeur 10 (To 10).
• La phrase s'affiche à l'écran.
• La variable A voit augmenter sa valeur de 1 (Next).

La boucle s'exécutera alors jusqu'à ce que la variable A ait atteint la valeur 10 ; c'est-à-dire lorsqu'elle aura écrit 10 fois la phrase.
Voilà déjà un premier avantage à être programmeur... non ? Les punitions faites en 30 secondes, c'est pas beau, ça ?


Ben on ne peut pas dire que vous n'êtes pas curieux. Mais de toute manière, cette question tombe à pic : c'est exactement ce que je veux vous montrer après. Il est donc possible de choisir le pas (eh oui, c'est comme ça que ça s'appelle) pour augmenter la valeur différement.

For, To, Step, Next

C'est exactement la même syntaxe, sauf que sur la ligne où l'on déclare les valeurs de départ et d'arrivée, on rajoute le pas :

For valeur de départ To valeur d'arrivée Step pas

Je n'ai pas vraiment d'idée pour trouver un bon exemple ; on va donc en faire un débile. Créons un programme qui compte de 2 en 2 en partant de 10, et en allant à 30 :

Code : Autre
Pas besoin de vous expliquer ce programme, vous l'avez compris ?
Vous devez vous dire (vu les exemples que j'ai choisis) que cette fonction n'est pas très utile, mais vous vous trompez lourdement ; lorsque vous ferez des jeux, elle vous sera plus qu'utile.