FANDOM


Les conditions permettent d’exécuter du code uniquement si certains critères sont réunis. Par exemple, on va pourvoir faire avancer le joueur uniquement si celui-ci appuie sur la touche appropriée ou jouer une animation de mort uniquement si la vie du personnage est tombée à zéro.

En programmation, un test conditionnel retourne vrai ou faux (un booléen). Soit le test compare deux expressions soit il évalue l'équivalent (vrai/faux) d'une expression. C'est uniquement si la condition est vraie que le code à l'intérieur du bloc de la structure conditionnelle est exécuté.

Voici quelques exemples simples (on imagine que le joueur subit des dégâts) :

degats_subis = 60
vie_joueur = 50
joueur_est_mort = false -- le joueur n'est pas encore mort

vie_joueur = vie_joueur - degats_subis -- la vie du joueur baisse

if vie_joueur > 0 then
    print("Le joueur est en vie") -- si la vie du joueur est strictement supérieure à zéro, celui-ci est encore en vie
end

if vie_joueur <= 0 then
    joueur_est_mort = true -- si la vie du joueur est inférieure ou égale à zéro, celui-ci est déclaré comme mort
end

if joueur_est_mort then
    print("RIP") -- si le joueur est mort, on affiche son épitaphe
end

Si vous vous amusez à changer les valeurs de degats_subis et vie_joueur, vous verrez que ce qui est affiché dans la console n'est pas la même chose à chaque fois.

Le If est la structure conditionnelle la plus simple. If signifie "si" en anglais, then signifie "alors", end signifie "fin". La condition est placée entre if et then et le code qui sera exécuté uniquement si la condition retourne vrai est placée entre then et end.

Les conditions posent la question de savoir si l'expression placée entre if et then est égale à true et attendent donc de l'expression qu'elle retourne un booléen. Ainsi les opérateurs de comparaisons retournent un booléen mais ce n'est pas forcément le cas des opérateurs logiques.

Si l'expression n'est pas un booléen, la valeur qu'elle retourne sera alors transformée en booléen selon la règle suivante : toute valeur qui n'est ni false, ni nil est équivalente à true (est considérée comme étant vraie). Notez donc qu'en Lua le chiffre zéro est équivalent à true, ce qui n'est pas le cas dans la majorité des autres langages de programmation.

Opérateurs de comparaisonModifier

Dans les deux premiers exemples ci-dessus, nous effectuons une comparaison de deux valeurs. Ces comparaisons se font toujours deux par deux et au moyen d'un des opérateurs de comparaison.

  • L'opérateur d'égalité == : il renvoie vrai si les deux valeurs comparées sont égales.
5 == 5 -- est vrai
5 == 10 -- est faux
5 == 5.01 -- est faux
5 == "cinq" -- est faux
"cinq" == "cinq" -- est vrai
"cinq" == "cinq " -- est faux (il y a une espace en plus à la fin du cinq à droite)
false == nil -- est faux
false == false -- est vrai

Notez que les opérateurs de comparaison ne transforment pas les types des valeurs qu'ils comparent (comme le font les opérateurs arithmétique ou l'opérateur de concaténation).

5 == "5" -- est faux
5 == tonumber("5") -- est vrai
tostring(5) == "5" -- est vrai
true == "true" -- est faux
  • L'opérateur d'inégalité ~= : il renvoie vrai si les deux valeurs comparées sont différentes (le signe à gauche du signe égal est un tilde, touche AltGr+2) (dans les autres langages de programmation, cet opérateur s'écrit souvent !=).
5 ~= 5 -- est faux
5 ~= 10 -- est vrai
5 ~= 5.01 -- est vrai
5 ~= "cinq" -- est vrai
"cinq" ~= "cinq" -- est faux
"cinq" ~= "cinq " -- est vrai
true ~= true -- est faux
  • L'opérateur de stricte infériorité < : il renvoie vrai si la valeur de gauche est strictement inférieure (c'est à dire inférieure mais pas égale) à la valeur de droite.
6 < 5 -- est faux
5 < 5 -- est faux, car les deux cotés sont égaux
4 < 5 -- est vrai
  • L'opérateur d'infériorité <= : il renvoie vrai si la valeur de gauche est inférieure ou égale à la valeur de droite.
6 <= 5 -- est faux
5 <= 5 -- est vrai
4 <= 5 -- est vrai
  • L'opérateur de stricte supériorité > : il renvoie vrai si la valeur de gauche est strictement supérieure (c'est à dire supérieure mais pas égale) à la valeur de droite.
6 > 5 -- est vrai
5 > 5 -- est faux, car les deux cotés sont égaux
4 > 5 -- est faux
  • L'opérateur de supériorité >= : il renvoie vrai si la valeur de gauche est supérieure ou égale à la valeur de droite.
6 >= 5 -- est vrai
5 >= 5 -- est vrai
4 >= 5 -- est faux

Opérateurs logiquesModifier

Les opérateurs logiques vont permettre de combiner plusieurs tests afin de créer une condition plus évoluée.

  • not : cet opérateur inverse la valeur de retour de l'expression qu'il précède.
not false -- est vrai
not true -- est faux
not nil -- est vrai
not 5 == 5 -- est faux, notez que cela reviens à écrire : 5 ~= 5
not 6 <= 5 -- est vrai, cela reviens à écrire : 6 > 5

Cet opérateur n'est en fait jamais utilisé comme dans les exemples ci-dessus. Il est utilisé avec des variables ou des fonctions pour inverser leur signification. Not signifie ne pas en anglais, il indique la négation. Dans les autres langages de programmation il est souvent représenté par un point d'exclamation.

if not joueur_est_mort then
    -- ce code sera exécuté si (not joueur_est_mort) est vrai, c'est à dire si joueur_est_mort contient false lorsque le joueur est en vie
end
  • and : Cet opérateur est placé entre deux expressions dont il évalue l'équivalence vrai/faux et retourne la valeur que retourne soit l'expression de gauche, soit l'expression de droite. Il retourne la valeur de l'expression qui est à sa gauche si celle-ci est équivalente à false. En revanche il retournera la valeur de droite si la valeur de gauche est équivalente à true.
print( false and true ) -- affiche false, car la valeur de gauche est équivalente à false
print( false and nil ) -- affiche false
print( nil and true ) -- affiche nil, toujours pour la même raison
print( nil and 20 ) -- affiche nil

print( true and false ) -- affiche false, car la valeur de gauche est équivalente à true
print( true and nil ) -- affiche nil
print( true and 20 ) -- affiche 20
print( 20 and 10 ) -- affiche 10

Vous voyez que le seul cas où l'opérateur and retourne une expression équivalente à true est lorsque les deux expressions dont il est entouré sont équivalentes à true.

  • or : Cet opérateur s'utilise comme and mais se comporte de manière inverse : il retourne la valeur de l'expression qui est à sa gauche si celle-ci est équivalente à true. En revanche il retournera la valeur de droite si la valeur de gauche est équivalente à false.
print( true or false ) -- affiche true, car la valeur de gauche est équivalente à true
print( true or nil ) -- affiche true
print( true or 20 ) -- affiche true
print( 20 or 10 ) -- affiche 20

print( false or true ) -- affiche true, car la valeur de gauche est équivalente à false
print( false or nil ) -- affiche nil
print( nil or true ) -- affiche true
print( nil or 20 ) -- affiche 20

Ici le comportement est différent, puisque l'opérateur or retourne une expression équivalente à true, lorsque au moins l'une des deux expressions qu'il évalue est équivalente à true.

On peut résumer le comportement de and et or ainsi :

  • and : retourne vrai uniquement lorsque les deux expressions sont vraies
  • or : retourne vrai lorsque l'une des deux expressions est vraie

Tout comme les opérateurs arithmétiques, les opérateurs logiques et de comparaison peuvent se combiner avec des parenthèses afin de créer des conditions complexes. Exemple bidon :

a ~= b and (c < d or not joueur_est_mort)

Les structures conditionnellesModifier

ifModifier

Nous l'avons déjà vu :

if [condition] then
   [code exécuté si condition est vrai]
end

elseModifier

if [condition] then
   [code exécuté si condition est vraie]
else
   [code exécuté si condition est fausse]
end

C'est une variante de la première où le code placé dans le bloc qui commence par else (qui signifie "ou bien", ou "sinon") est exécuté uniquement si la condition (entre if et then) est fausse.

C'est donc forcément l'un des deux blocs (ni les deux, ni aucun des deux) qui est exécuté.

-- je reprend ici l'un des premiers exemple, mais en plus court grâce à au mot clé else
if vie_joueur > 0 then
    print("Le joueur est en vie")
else -- else remplace ici "if vie_joueur <= 0 then" puisque c'est exactement l'inverse de "vie_joueur > 0"
    joueur_est_mort = true
end

elseifModifier

if [condition 1] then
   [code exécuté si condition 1 est vraie]

elseif [condition 2] then
   [code exécuté si condition 1 est fausse et condition 2 est vraie]

elseif [condition 3] then
   [code exécuté si condition 1 et 2 sont fausses et condition 3 est vraie]

else
   [code exécuté si toutes les conditions ci-dessus sont fausses]
end

Elseif ("sinon si" en anglais) permet de créer une série de conditions mutuellement exclusives. C'est à dire que le programme va s'arrêter de lire les conditions dès qu'il en trouve une de vrai puis sauter jusqu'au mot clé end sans lire les suivantes.

Les cas où l'utilisation de elseif au lieu de l'utilisation d'un enchainement de ifs est obligatoire ne sont pas courants. Si les conditions sont vraiment mutuellement exclusives comme dans l'exemple ci-dessous, cela n'apporte pas vraiment d'avantage à part de rendre le code un peu plus court et surtout plus logique. Leur utilisation n'est vraiment obligatoire que lorsque l'on veut justement empêcher des conditions d'être lues si une condition placée plus haut dans les code se révèle vraie.

if vie_joueur < 33 then
   print("Le joueur est mal en point !")

elseif vie_joueur >= 33 and vie_joueur < 66  then
   print("Le joueur va bien.")

elseif vie_joueur >= 66 then -- ici, j'aurais très bien pu utiliser else au lieu de elseif puisque (vie_joueur >= 66) est le seul cas de figure possible restant
   print("Le joueur est en pleine forme !")
end
-- notez que l'utilisation de else n'est pas obligatoire

ConclusionModifier

Ce qu'il faut retenir des conditions, c'est qu'elles vont permettre de tester la valeur de variables dont est composée votre jeux et de les comparer entres elles afin de faire exécuter du code uniquement lorsque certains critères sont réunis.

Comparer des expressions se fait grâce aux opérateurs de comparaison :

  • == (égal)
  • ~= (différent de)
  • < (strictement inférieur à)
  • <= (inférieurs ou égal à)
  • > (strictement supérieur à)
  • >= (supérieur ou égal à)

Combiner des expressions est possible grâce aux opérateurs logiques :

  • not (qui inverse la valeur de l'expression qu'il précède)
  • and (qui retourne vrai lorsque les deux expressions qui l'entourent sont vraies)
  • or (qui retourne vrai lorsque l'une des deux expressions qui l'entourent est vraie)

Ces différents opérateurs s'utilisent au sein des structures conditionnelles if, elseif, et/ou else.

Nous reparlerons des conditions au chapitre sur les boucles car celles-ci servent entre autre à répéter du code plusieurs fois en fonction d'une condition. L'autre grande utilité des boucles et de parcourir le contenus des tableaux, qui seront étudiés dès le prochain chapitre.

Interférence d'un bloqueur de publicité détectée !


Wikia est un site gratuit qui compte sur les revenus de la publicité. L'expérience des lecteurs utilisant des bloqueurs de publicité est différente

Wikia n'est pas accessible si vous avez fait d'autres modifications. Supprimez les règles personnalisées de votre bloqueur de publicité, et la page se chargera comme prévu.

Sur le réseau FANDOM

Wiki au hasard