|
Programmation en language LUA | |
Les expressions en LUA |
Les expressions en LUA sont évaluées afin d'exécuter les calculs pour affecteer des valeurs aux variables ou pour passer des arguments aux fonctions.
Nous emploierons = la notation racourcie dans ce document.
Les valeurs peuvent facilement être assignées à une variable,
par exemple,
> x = 7
> print(x)
7
> = 7
7
Lua utilise les opérateurs habituels d'arithmétique binaire.
> = 2+3, 5-12, 2*7, 7/8
5 -7 14 0.875
> = 5*(2-8.3)/77.7+99.1
98.694594594595
Négation unaire :
> = -(-10), -(10)
10 -10
Puissance de :
> = 7^2, 107^0, 2^8
49 1 256
On fournit des opérateurs relationnelles qui
renvoient les valeurs booléennes true ou false.
== égale à
~= pas égale à
< moins que
> plus grand que
<= inférieur ou égal à
>= supérieur ou égal à
Exemples :
> = 1 == 1, 1 == 0
true false
> = 1 ~= 1, 1 ~= 0
false true
> = 2 < 7, 2 > 7
true false
> = 3 <= 7, 7 <= 7, 8 <= 7
true true false
> = 3 >= 7, 7 >= 7, 8 >= 7
false true true
Ceux-ci opérent également sur des chaînes de caractères et d'autres types.
> = "abc" < "def"
true
>
= "abc" > "def"
false
>
= "abc" == "abc"
true
>
= "abc" == "a".."bc"
true
Les objets ne seront pas égaux si les types sont différents ou se rapportent à différents objets.
> = {} == "table"
false
> = {} == {} -- two different tables are created here
false
> t = {}
> t2 = t
> = t == t2 -- we're referencing the same table here
true
La coercition ne fonctionne pas ici, les types doivent être convertis explicitement. Voir Nombres et Chaînes pour l'explication de la coercition.
> = "10" == 10
false
>
= tonumber("10") == 10
true
Lua dispose des opérateurs logiques and, or et not.
En Lua tous nil et valeur booléenne false représentent
false (faux) dans
une expression logique. Quelque chose qui n'est pas faux (l'un
ou l'autre nil ou false) est true (vrai).
Il
y
a plus de notes sur les implications de ceci à la fin de cette page.
> = false==nil -- although they represent the same
thing they are not equivalent
false
> = true==false, true~=false
false true
> = 1==0
false
>
= does_this_exist -- test to see if variable "does_this_exist" exists.
no, false.
nil
not - (n'est pas)
Le mot-clé not inverse une valeur
logique d'expression :
> = true, false, not true, not false
true false false true
> = not nil -- nil represents false
true
> = not not true -- true is not not true!
true
>
= not "foo" -- anything not false or nil is true
false
and - (et)
L'opérateur binaire and ne
renvoie pas nécessairement une valeur
booléenne true ou false à l'expression logique X
et y. Dans certains languages, l'opérateur and retourne une
valeur booléenne
dépendante des deux valeurs entrées. Par contre dans Lua, elle renvoie
le
premier
argument si sa valeur est false ou nil, et le
deuxième argument si le premier argument n'était pas faux.
Ainsi, un booléen est seulement retourné si les valeurs passées
étaient booléen.
> = false and true -- false is returned because it
is the first argument
false
> = nil and true -- as above
nil
> = nil and false
nil
>
= nil and "hello", false and "hello"
nil false
Toutes les expressions ci-dessus renvoient le premier argument. Toutes les expressions suivantes renvoient le deuxième argument, car le premier est vrai.
> = true and false
false
>
= true and true
true
>
= 1 and "hello", "hello" and "there"
hello there
>
= true and nil
nil
Comme vous pouvez voir que les expressions logiques sont encore évaluées correctement mais nous avons un comportement intéressant en raison des valeurs retournées.
or L'opérateur binaire également ne renvoie pas nécessairement
une valeur booléenne (voir les notes pour and ci-dessus). Si le premier argument n'est pas faux
il est retourné, autrement le deuxième argument est retourné.
> = true or false
true
> = true or nil
true
>
= "hello" or "there", 1 or 0
hello 1
Ceci peut être une propriété très utile. Par exemple, plaçant des valeurs par défaut dans une fonction :
> function foo(x)
>>
local value = x or "default" -- if argument x is false or nil, value
becomes "default"
>> print(value, x)
>> end
>
> foo() -- no arguments, so x is nil
default nil
> foo(1)
1 1
> foo(true)
true true
>
foo("hello")
hello hello
Les opérateurs ternaires sont un dispositif utile dans le C. par exemple. int value = x>3 ? 1 : 0;
Ce comportement peut être partiellement émulé dans Lua
en utilisant les opérateurs logiques and et or.
La forme de C :
value = test ? x : y;
traduit en Lua :
value = test and x or y
Par exemple.
> print( 3>1 and 1 or 0 )
1
>
print( 3<1 and 1 or 0 )
0
>
print( 3<1 and "True" or "False" )
False
>
print( 3>1 and true or "false" )
true
Cependant, il y a une limite, ceci
fonctionne seulement quand la première valeur de retour n'est pas nil ou false.
> print( 3>1 and 1 or "False" ) -- works
1
>
print( 3>1 and false or "oops" ) -- failed, should return false
oops
>
print( 3>1 and nil or "oops" ) -- failed, should return nil
oops
Un point important à noter est que la valeur 0 n'est pas une condition
d'essai fausse dans Lua.
Dans d'autre langage, par exemple C, un test :
if (0)
printf("true");
else
printf("false");
montrerait "false".
Dans Lua,
> if 0 then
>>
print("true")
>>
else
>>
print("false")
>>
end
true
affiche "true".
Vous devriez employer false, ou nil au
lieu de 0 :
> if false then print("true") else print("false")
end
false
>
if nil then print("true") else print("false") end
false
Pourquoi ?
La raison de ceci est historique. Lua n'a pas
soutenu les types booléens (c.-à-d. true et false)
avant la version 5.0. Avant la version 5.0 une valeur nil représentatit
false (faux).
Maintenant, tous les deux nil et false agiront en tant
qu'état faux dans une
expression conditionnelle. Par exemple,
> if nil then print("true") else print("false")
end
false
>
if 1 then print("true") else print("false") end
true
>
if 0 then print("true") else print("false") end
true
>
if 1==2 then print("true") else print("false") end
false
Un autre point à noter est celui true et false ne
sont des valeurs numériques, par
exemple, 1 et 0 comme dans d'autres languages.
> = true, false
true false
> = 1 + true
stdin:1: attempt to perform arithmetic on a boolean value
stack traceback:
stdin:1: in main chunk
[C]: ?
En outre, nil est forcé à une valeur
booléenne une fois utilisé avec un opérateur logique :
> = not nil
true
>
= not 1
false
>
= not 0
false
 www.loriotpro.com |
|