Sans les boucles et conditions, notre programme s'exécuterait de façon séquentielle et nos programmes serait bien limités :-D . \\
Vous allez voir qu'avec tout ça, vous pourrez commencer à faire plein de petits programmes sympathiques.
Les conditions
Les conditions permettent de bifurquer à l'intérieur d'un programme. Exemple :
Selon la puissance du moteur de la voiture, on indique à l'utilisateur
si cette voiture est puissante sinon on indique qu'elle ne l'est pas
== Structure de condition IF THEN ELSE ==
C'est la structure la plus basique :
1
2
3
| IF condition THEN
ENDIF
|
est donc comme vous vous en doutez, la valeur à tester. Les signes de conditions sont :
- > : strictement supérieur
- < : strictement inférieur
- >= : supérieur ou égal
- < = : inférieur ou égal
- = : égal
- <> : différent de
On peut ainsi comparer 2 valeurs, par exemples 2 variables : ''IF Variable1 = Variables2 then''
Ici, le signe "
= " marque ici un test d'égalité, et non une affectation de valeur dans une variable (comme dans a=1)
Maintenant petit exemple pour mettre en pratique :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| PUBLIC SUB Main()
DIM age AS INTEGER
PRINT "Quel est votre age ? "
INPUT age
IF age >= 18 THEN
PRINT "Vous êtes majeur."
ELSE
PRINT "Vous êtes mineur."
ENDIF
END
|
Le mot clé
ELSE est facultatif. Exemple :
1
2
3
4
5
6
7
8
9
10
11
| ' Gambas module file
PUBLIC SUB Main()
DIM puissance AS INTEGER = 15 'puissance en ch
IF puissance < 15 THEN
PRINT "Tu veux pas changer de voiture ? :p "
ENDIF
END
|
Autre remarque, le mot-clé
ENDIF est optionnel si il y a qu'une seule instruction à exécuter :
1
2
3
4
5
6
7
| PUBLIC SUB Main()
DIM puissance AS INTEGER = 15 'puissance en ch
IF puissance < 15 THEN PRINT "Tu veux pas changer de voiture ? :p "
END
|
== Structure de condition SELECT CASE ==
On utilise cette structure lorSqu'il y a de nombreuses valeurs à tester, rendant ainsi le code plus clair à lire :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| PUBLIC SUB Main()
DIM pays AS STRING
PRINT "De quel pays venez-vous ?"
INPUT pays
pays = LCase(pays) 'enlève les majuscules éventuelles
SELECT CASE pays
CASE "france"
PRINT "Bonjour !"
CASE "england"
PRINT "Hello !"
CASE "espana"
PRINT "Ola !"
CASE "portugal"
PRINT "Hola !"
CASE ELSE
PRINT"??"
END SELECT
END
|
Cette structure se comprend d'elle même :D.
Les boucles
Les boucles permettent de répéter une ou plusieurs instructions. Il existe 3 types de boucles permettant de faire la même chose d'une manière différente.
FOR
La boucle
FOR permet de répéter n fois un bloc d'instructions.
1
2
3
4
5
6
7
8
9
| PUBLIC SUB Main()
DIM i AS INTEGER
FOR i = 1 TO 5
PRINT "Valeur de i : " & i
NEXT
END
|
Quand Gambas rentre dans la boucle pour la première fois, il affecte la valeur 1 à i, puis exécute les instructions suivantes jusqu'à ce qu'il rencontre le mot clé NEXT. Gambas revient alors au début de la boucle, puis incrémente la valeur de i, c'est à dire lui ajoute 1 : si i valait 1 alors i vaudra 2 après cette incrémentation. Et ainsi de suite, jusqu'à ce qu'il atteigne la valeur maximale que vous avez fixé (ici c'est 5). Les instructions dans la boucle seront donc lues 5 fois :
1
2
3
4
5
| Valeur de i : 1
Valeur de i : 2
Valeur de i : 3
Valeur de i : 4
Valeur de i : 5
|
Cette boucle incrémente i (i=1, puis i=2 etc). Si pour une raison quelconque vous avez besoin de 'décrementer' i ou que l'incrément soit différent de 1, utilisez le mot clé STEP :
1
2
3
4
5
6
7
8
9
| PUBLIC SUB Main()
DIM i AS INTEGER
FOR i = 5 TO 1 STEP -1
PRINT "Valeur de i : " & i
NEXT
END
|
La valeur de l'incrément est ici -1, la boucle est decrescendo. Vous pouvez aussi utiliser une valeur de 2 par exemple pour faire une boucle avec des valeur de i impairs (''FOR i=1 to 7 STEP 2'')
DO...LOOOP
Parfois on ne connait pas à l'avance le nombre de boucles à faire. Mais on sait dans quelle condition la boucle doit s'achever. La boucle DO/LOOP est alors préféré à FOR/NEXT. Voici un exemple :
1
2
3
4
5
6
7
8
9
10
11
12
13
| PUBLIC SUB Main()
DIM resultat AS INTEGER
PRINT "Combien font 2 fois 2 ?"
DO
INPUT resultat
LOOP UNTIL resultat = 4
PRINT "Bravo, vous avez trouvé :-) "
END
|
Dans cet exemple la boucle repose sur une condition : le résultat entré doit être égal à 4, sinon on continue la boucle. En français cela donne : fais (DO) jusqu'à ce que (LOOP UNTIL) le résultat soit bon (resultat=4). Une autre manière d'écrire cette boucle aurait été :
1
2
3
| DO
INPUT resultat
LOOP WHILE resultat <> 4
|
Dans ce cas, WHILE (tant que) remplace UNTIL (jusqu'à ce que). La condition est donc aussi changée : boucle tant que le résultat est
différent de 4.
WHILE
La boucle
WHILE peut se traduire par
tant que.
Tant que la valeur de Âge est inférieur a 10 ... Exemple :
1
2
3
4
5
6
7
8
9
10
11
12
| ' Gambas module file
PUBLIC SUB Main()
DIM age AS INTEGER
WHILE age < 10
INC age
PRINT "Valeur de age : " & age
WEND
END
|
Résultat
1
2
3
4
5
6
7
8
9
10
| Valeur de age : 1
Valeur de age : 2
Valeur de age : 3
Valeur de age : 4
Valeur de age : 5
Valeur de age : 6
Valeur de age : 7
Valeur de age : 8
Valeur de age : 9
Valeur de age : 10
|
====================
Navigation :
<-- Liens du Wiki : <--<-- Sommaire du WIKI : <-- <-- Rappels de Programmation <--====================
Documentation :
====================