Aller au menu - Aller au contenu
 Zozor

Les conditions Editer


Informations sur le tutoriel

AvatarAvatar
Auteurs : kindermoumoute et wag1
Difficulté : Facile
Temps d'étude estimé : 6 minutes


Plus d'informations Plus d'informations
On retrouve les conditions dans beaucoup de langages, mais qu'est ce que les conditions?
C'est ce que nous allons essayer de comprendre durant ce chapitre.
Chapitre précédent Sommaire Chapitre suivant

Explication de la condition Editer

Une condition sert à tester une variable. Dans votre vie de tous les jours vous êtes confronté à de nombreuses conditions, plus ou moins sympathiques, par exemple :
Citation
Si j'ai donné deux euros à la boulangère, alors j'ai du pain.

Ou encore :
Citation
Si je n'ai pas un donné deux euros à la boulangère, alors je n'ai pas de pain.

Cette deuxième condition vas être une conséquence de la première et vice versa.

Donc dans un programme de jeu ça pourrait donner :
Code : Algorithme - Sélectionner
1
2
Si je meurs
Alors j'ai perdu la partie


Ici en Axe Parser avec V qui est égal à 1 s'il reste une vie, ou V est égal à 0 s'il ne reste aucune vie :
Code : Axe Parser - Sélectionner
1
2
3
:If V=0
:Disp "Game Over"
:End


Si l'on examine ce code avec précision :
Code : Axe Parser - Sélectionner
1
:If V=0

S'il n'y a plus de vie.
Code : Axe Parser - Sélectionner
1
:Disp "Game Over"

On affiche Game Over.
Code : Axe Parser - Sélectionner
1
:End


Toute structure conditionnelle se termine par un End. Celui ci est présent pour signaler à notre programme que notre condition est terminé, et que le code reprend son cours normal. Si il n'y a pas de End, ou qu'il y a un End en trop, vous aurez une erreur ERR:BLOCK lors de la compilation.

On trouvera la commande If ici : Image utilisateur Image utilisateur
Et la commande End là : Image utilisateur Image utilisateur


"V=0" ? ça ressemble drôlement à des booléens !


C'est là que je voulais en venir, le principal intérêt sera d'utiliser des booléens dans des conditions, et croyez moi ça facilite vraiment la vie!

Les conditions ; si, sinon, ou sinon. Editer

On a vue précédemment les conditions les plus courtes :
Code : Axe Parser - Sélectionner
1
2
3
4
:If (maCondition)
:.le code à exécuter
:End
:.toujours terminer par un End!


Note : maCondition sera donc une opération booléenne!


Maintenant, si l'on veut exécuter un code quand la condition est vraie, et un autre quand est est fausse, on utilisera Else de la façon suivante :
Code : Axe Parser - Sélectionner
1
2
3
4
5
6
7
:If (maCondition)
:.le code à exécuter si la condition est VRAI
:Else
:.sinon on exécute le code suivant
:."code suivant"
:End
:.(on oublie pas le End)


On trouvera Else ici : Image utilisateur Image utilisateur



Mais mon code va vite fait se remplir de If, Else et End !


Oui! C'est un programme!
Mais je vous rassure, on peut organiser ses conditions, grâce à une autre commande : ElseIf

Elseif sera utilisé comme ceci :
Code : Axe Parser - Sélectionner
1
2
3
4
5
6
7
8
:If (maPremièreCondition)
:.le code à exécuter si la condition est vraie
:Elseif (maDeuxièmeCondition)
:.sinon si la deuxième condition est vraie, on exécute le code suivant
:."code suivant"
:Else
:.sinon ce code est exécuté.
:End


Par exemple je reprend notre système de vie :
Code : Axe Parser - Sélectionner
1
2
3
4
5
6
7
:If V=0
:Disp "Game over"
:Elseif V=1
:Disp "Il ne vous reste plus qu'une vie !"
:Else
:Disp "Vous êtes en parfaite santé"
:End



Bon, jusque la ce n'est pas trop compliqué? j'espère que non, car maintenant on va rajouter les calculs booléens (que vous maitrisez parfaitement :-° ) dans ces conditions.

La puissance des conditions prend tout son ampleur lorsqu'on la mélange avec les tests logiques que l'on a vu précédemment :
Code : Axe Parser - Sélectionner
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
:If A=0
:.Mon code
:End

:If A≠0
:.Mon code
:End

:If A<0
:.Mon code
:End

:If A>0
:.Mon code
:End

:If A≥0
:.Mon code
:End

:If A≤0
:.Mon code
:End


Puis les comparateurs logiques :
Code : Axe Parser - Sélectionner
1
2
3
4
5
6
7
8
9
10
11
:If (A=0) and (B≠8)
:.Mon code
:End

:If (A<0) or (B>8)
:.Mon code
:End

:If (A≥0) xor (B≤8)
:.Mon code (ne sera jamais exécuté ici)
:End


Ici on a vu les conditions les plus simples à comprendre. Mais grâce aux booléens, on peut simplifier l'écriture suivante :
Code : Axe Parser - Sélectionner
1
2
3
:If A=1
:.le code s'exécutera si A est VRAI
:End


En celle ci :
Code : Axe Parser - Sélectionner
1
2
3
:If A
:.le code s'exécutera si A est VRAI
:End


Ici, A s'exécutera si il est plus grand ou égale à 1


Et si A est négatif, il n'y a pas un moyen plus simple que If A≠0


Si il y existe les conditions inversé, j'allais en parler :-° .

Les conditions inverse Editer

En faite, les conditions inversés sont exactement pareil que les conditions normale. On rajoutera juste le point d'exclamation ! : Image utilisateur Image utilisateur Image utilisateur

Code : Axe Parser - Sélectionner
1
2
3
:!If A
:.Si A est FAUX, on exécute ce code
:End


Il marchera donc pour toutes les variantes de la structure conditionnelle vu précédemment :
Secret (cliquez pour afficher)
Code : Axe Parser - Sélectionner
1
2
3
4
5
:!If (maCondition)
:.le code à exécuter si la condition est FAUX
:Else
:.sinon on exécute ce code
:End

Code : Axe Parser - Sélectionner
1
2
3
4
5
6
7
:!If V
:Disp "Game over"
:Else!if V>1
:Disp "Il ne vous reste plus qu'une vie !"
:Else
:Disp "Vous êtes en parfaite santé"
:End

Code : Axe Parser - Sélectionner
1
2
3
4
5
6
7
8
9
10
11
:!If (A=0) and (B≠8)
:.Mon code
:End

:!If (A<0) or (B>8)
:.Mon code
:End

:!If (A≥0) xor (B≤8)
:.Mon code (sera toujours exécuté ici)
:End

Les conditions décrémentés Editer

Ce type de condition est plus dur à comprendre car en plus de tester une conditions, il va agir sur la variable testé en la décrémentant de 1 à chaque fois qu'elle est testé. Quand cette variable atteint 0, elle est restitué à sa valeur maximum que l'on aura définie.
Code : Axe Parser - Sélectionner
1
2
3
:DS<(VARIABLE,VALEURMAXIMUM) 
:.code1 
:End


La commande décrémenter DS< se trouve ici : Image utilisateur Image utilisateur Image utilisateur


Un exemple de conditions décrémentés :
Code : Axe Parser - Sélectionner
1
2
3
:DS<(X,3) 
:.code1 
:End

La première fois que la condition sera testé, X=3, comme X n'est pas égale à 0 on enlève 1 à X et le code1 est ignoré, la deuxième fois X=2, pareil on enlève 1 et on ignore code1, la troisième fois X=1, on enlève 1 et on ignore toujours le code1. La quatrième fois X=0, le code1 est exécuté, et X=3.

Mais comment cette condition peut être testé plusieurs fois dans le même code? o_O


Cela tombe bien, c'est le sujet de notre prochain chapitre : Les boucles.

Q.C.M.

Code : Axe Parser - Sélectionner
1
2
3
4
5
6
7
:If V
:.codeA
:Else!If V
:.codeB
:Else
:.codeC
:End

Quel est la particularité de ce code?
(Les codeA, codeB et codeC sont considérés comme des codes quelconques)
Code : Axe Parser - Sélectionner
1
2
3
4
5
:4→A
:DS<(A,5)
:End
:Disp A►Dec
:Pause 2000

Que va afficher ce code?
Code : Axe Parser - Sélectionner
1
2
3
4
5
6
7
8
9
10
11
12
13
14
:If V=5
:Disp "En plein forme
:ElseIf V=4
:Disp "Un remontant ne ferait pas de mal
:ElseIf V=3
:Disp "Tiens, les arbre n'ont plus de feuille
:ElseIf V=2
:Disp "Tu n'a plus beaucoup de vies
:Else If V=1
:Disp "Attention
:Else!If V
:Disp "Game Over
:Else
:Disp "plop


Quel est le problème de ce code?
Code : Axe Parser - Sélectionner
1
2
3
4
:If (A=P)
:Disp "
:Else
:End

Ce code compilera-t-il?

Statistiques de réponses au QCM


Chapitre précédent Sommaire Chapitre suivant

Informations sur le tutoriel

Retour en haut Retour en haut

Créé : Le 09/10/2010 à 21:19:22
Avancement : 95%
Licence : Copie non autorisée