Partie I : 5) Les boucles et les sauts

 
Voila un chapitre très intéressant puisqu'il concerne les boucles et les sauts. Ils vous serons très utile dans presque toutes vos applications futur.




Qu'est ce qu'une boucle ?


Les boucles sont des systèmes qui permettent de répéter plusieurs fois la/les même(s) action(s).


Dans nos programme, une fois l'action (print, input, etc.) terminée le programme passait à l'instruction suivante, grâce aux boucles, notre programme va répéter une portion de code un certain nombre de fois ou tant qu'une condition est vraie.

Par exemple, imaginons que vous êtes un élève en 2156 (plus de papier, que des ordinateurs :p ), vous avez - pour plaisanter - envoyé un virus à votre voisin de réseau, le professeur vous donne malheureusement une punition : recopiez 2500 fois "Je ne dois pas envoyer de virus à mes voisins de réseau pendant les cours." uniquement avec des print.

Vous commencez tout naturellement à faire votre punition (avec des copier/coller, faut pas exagérer non plus :D ). Mais il existe une solution beaucoup plus pratique et qui fait faire beaucoup moins de gymnastique à vos chers petits doigts. ^^ Cette solution miracle s'appelle la boucle et c'est ce que nous allons découvrir dans ce chapitre.


La boucle For ... Next


Il y a plusieurs types de boucles en LB. Les deux sortes de boucles les plus utilisées sont la boucle for...next et la boucle while...wend.
Dans ce sous-chapitre, nous allons découvrir ensemble la boucle for...next. Et puisqu'un exemple vaut mieux qu'un long discours :

Code VB :
 
for i = 1 to 250
    print "Je ne dois pas envoyer de virus à mes voisins de réseau pendant les cours."
next
 


La première ligne est la plus importante :
D'abord il y a le mot-clé for qui signifie que l'on va commencer une boucle standard avec une variable que l'on va incrémenter (augmenter) à chaque itération (à chaque fois que la portion de code à l'intérieur de la boucle est exécutée).

Ensuite nous avons i = 1. i est la variable qui va être incrémentée, c'est à dire que chaque fois que la boucle arrive à sa fin elle gagne un nombre prédéfini. On spécifie qu'elle est égale à 1 pour définir sa valeur de départ et obtenir ainsi le bon nombre d'itérations, par exemple si i = 240, on aura seulement 11 itérations (quand i = 250, la dernière est re-exécutée).

Ensuite nous avons un to. Il sert à séparer la variable et le nombre à atteindre.

Donc après vient le nombre à atteindre. Il peut être directement écrit comme ici ou l'on peut mettre une variable (c'est valable pour tous les nombres de cette ligne).

Voila pour la première ligne. Je ne vais pas commenter la deuxième car si vous ne comprenez pas c'est que vous n'avez pas lu le début du cours (ou que vous avez une mémoire de poisson rouge ^^ ).

Pour finir il y a le next qui termine la boucle.


Donc si vous avez tout compris, c'est LE code qui se trouve entre la ligne du for et celle du next qui va s'exécuter plusieurs fois.

Pour information la boucle for...next a un pas de 1 par défaut mais il peut être changer facilement :
Code VB :
 
for i = 1 to 250 step 2
    print "Je ne doit pas m'endormir pendant que j'apprends le Basic."
next
 

Donc au lieu de rajouter 1 à i lorsque la boucle est bouclée, on lui rajoute 2 (et on peut aussi lui enlever 2, pour cela il suffit de mettre un signe négatif devant le 2).


Si la variable est initialisée avec une valeur plus grande que le nombre à atteindre (celui après le to) la boucle ne s'exécutera tout simplement pas.
Bien sur cela ne s'applique que si le pas est positif, dès lors qu'il est négatif il faut que le nombre à atteindre soit inférieur à la valeur de la variable (pour que la boucle s'exécute au moins une fois).


Un peu de pratique


Pour que vous compreniez bien à quoi servent les boucles, je vous propose un petit exercice tout simple qui devrait servir à répéter 16 fois ces deux phrases :
Console:
Je suis la phrase 1
Et moi la phrase 2

(le "1" et le "2" devront changer en fonction de i)

Ce qui devrait donner :
Console:

Je suis la phrase 1
Et moi la phrase 2
Je suis la phrase 3
Et moi la phrase 4
Je suis la phrase 5
Et moi la phrase 6
Je suis la phrase 7
Et moi la phrase 8
Je suis la phrase 9
Et moi la phrase 10
Je suis la phrase 11
Et moi la phrase 12
Je suis la phrase 13
Et moi la phrase 14
Je suis la phrase 15
Et moi la phrase 16


A vous de jouer.
La variable déclarée dans le for (le i de notre exemple ci dessus) est réutilisable dans la boucle.

=========
=========
=========
=========
=============
===========
=========
=======
=====
===
=
Une solution :
Caché:
Code VB :
 
for compteur=1 to 16 step 2
    print "Je suis la phrase ";compteur
    print "Et moi la phrase ";(compteur+1)
next
 


Mais il y a une autre méthode (et même surement d'autres encore):
Code VB :
 
for compteur=1 to 16
    if compteur mod 2 = 1 then 'Quand compteur est impaire
        print "Je suis la phrase ";compteur
    else ' sinon
        print "Et moi la phrase ";compteur
    end if
next
 


Comme quoi il n'y a jamais une seule façon de faire.
Comparez avec votre propre code cela vous permettra de vous améliorer.


La boucle While ... Wend


Nous allons désormais voir la boucle While ... Wend
Cette boucle permet de faire directement la condition pour savoir si la boucle doit s'arrêter.
En effet, la boucle For ... Next (et les boucles en générale) doit tester à chaque tour si la valeur de la variable n'est pas supérieur ou égale à la valeur que l'on a mis après le to. Dans cette boucle, le teste n'est pas écrit explicitement alors que il l'est avec la boucle While ... Wend.
Je vais mettre un petit code :
Code VB :
 
compteur=1
while compteur <= 16
    print "Je suis la phrase ";compteur
    print "Et moi la phrase ";(compteur+1)
    compteur=compteur+2
wend
 



Première ligne : On initialise la variable compteur à 1.
Deuxième ligne : On commence la boucle while. While pourrait se traduire tant que, donc on peut traduire while compteur <= 16 par tant que compteur est inférieur ou égale à 16.
On remarque notre fameuse condition : compteur <= 16, c'est celle-ci qui est testée pour savoir si la boucle doit recommencer.

Si la condition est fausse dès le début de la boucle, les actions qui sont à l'intérieur ne s'exécuteront tout simplement pas. C'est pour ça que l'on a initialisé la variable compteur à 1.

Le deux lignes suivante sont déjà connues.

La ligne 5 sert à rajouter 2 dans la variable compteur.
Si on avait oublié cette ligne la boucle ne se serait jamais finie.
En effet, compteur serait toujours resté à 1 donc la condition aurait été toujours vraie.

Enfin on termine la boucle avec wend.

Comme vous pouvez le constater, ce code fait exactement la même chose que le petit exercice que je vous avais demandé de faire pour la boucle for ... next.
Ceci veut dire que l'on peut faire une boucle for avec une boucle while mais pas forcement l'inverse.

Voici une boucle while qui ne peut pas être faite avec une boucle for.
Code VB :
 
entre$=""
while entre$<>"quit"
    input "Taper quit si vous voulez quitter ";entre$
wend
 


Ce programme ne quitte que lorsque vous tapez quit.
On n'aurait pas (ou beaucoup moins facilement) pu le faire avec une boucle for.


Quelques autres boucles


Voila. Les deux boucles les plus utilisées en JB ont été vues.
Nous allons en voir quelques autres qui pourront être utiles.

La boucle do...loop while



Code
Code VB :
 
a=0
print "print un zero"
do
    print a
    a = a + 1
loop while a > 10
 

Explications
La boucle do...loop while fonctionne à peu près comme la boucle while sauf que la condition est testée à la fin de la boucle, ce qui veut dire que le contenu de la boucle s'exécutera au moins une fois. Cela peut être très utile.

La boucle do until...loop


Code
Code VB :
 
print "print 9 à 7"
b = 9
do until b = 6
    print b
    b = b - 1
loop
 

Explication
Cette nouvelle boucle fonctionne comme les autres, avec une condition, sauf que cette fois c'est si la condition est fausse que l'on continu la boucle.

La boucle do...loop until


Code
Code VB :
 
print "print un zero"
do
    print b
    b = b + 1
loop until b = 1
 

Explication
Cette boucle fonctionne sur le même principe que do until...loop mais la condition est testée à la fin ce qui fait que les actions qui sont à l'intérieur de la boucle seront exécutées au moins une fois.


Les sauts


Les sauts sont une notion primordiale en JB.
Ils servent à sauter (d'où leur nom) vers une étiquette.
En fait, ils permettent d'aller presque n'importe où dans votre code sans exécuter ce qu'il y a entre l'instruction du saut et l'étiquette.
Les étiquettes sont des mots placés sur une ligne de code. Elles servent à indiquer où le saut doit aller.
L'instruction de saut s'écrit goto [monEtiquette]. L'étiquette ne doit pas contenir d'espaces
Un petit exemple serait plutôt le bien venu non ?
Code VB :
 
print "Bonjour"
goto [monEtiquette]
print "Je suis un Zéro"
[monEtiquette]
print "Au revoir"
 

Si vous exécutez ce code vous constaterez qu'il n'écrit que :
Citation:

Bonjour
Au revoir

Alors que l'on aurait pu penser qu'il aurait écrit :
Citation:

Bonjour
Je suis un Zéro
Au revoir

On voie clairement l'action du saut, et si vous ne voyez toujours pas mettez la ligne goto [monEtiquette] en commentaire ( Rappel : on utilise le ' pour mettre en commentaire).

Bon, maintenant quelques petites remarques :
  • Les étiquettes sont délimitées pas des crochets [] et sont mises toutes seules sur un ligne. Elles peuvent avoir n'importe quelle nom mais pas d'espace (ni de retour à la ligne).
  • On ne peut pas mettre deux étiquettes identiques dans le même programme sous peine d'erreur.
  • Par contre on peut mettre autant de goto que l'on veut vers la même étiquette.
  • Petite astuce. Si vous voulez faire un saut conditionnel (c'est à dire qu'il n'y ai un saut que si la condition est vrai), faire ceci :
    Code VB :
     
    if a=1 then [mon_etiquette]
     

    Revient à faire cela :
    Code VB :
     
    if a=1 then goto [mon_etiquette]
     

    C'est simplement plus court.
  • L'étiquette peut être soit avant soit après l'instruction goto mais il faut faire très attention à ne pas provoquer des boucle infinie comme ceci (ne surtout pas tester ce code ) :
    Code VB :
     
    [etiquette]
    print "Bonjour"
    goto [etiquette]
     

    Chaque fois que l'on aura écrit Bonjour, le code reviendra au début ( à l'étiquette [etiquette] ), réécrira Bonjour et retournera au début, ainsi de suite pendant très longtemps.




Et voila vous savez presque tout sur les moyens de répéter plusieurs fois le même code sans devoir le réécrire
Maintenant on attaque un morceau important, les fonctions et les Sub :lu


 
Cette page a été consultée 6239 fois