|
Programmation en language LUA | |
Types des variables Lua |
Cette page est une introduction aux types de variables employés par le langage de script Lua. Chaque section présente un type de variable différent.
Lua permet l'arithmétique simple en utilisant les
opérateurs habituels pour ajouter, soustraire, multiplier et
diviser. Nous emploierons la fonction print() pour imprimer
le résultat de calculs. Les parenthèses autour
des arguments sont importantes et causeraient une erreur si elles étaient oubliées.
> print(2+2)
4
> print(2-7)
-5
> print(7*8)
56
> print(7/8)
0.875
Notez que les nombres ne sont pas arrondis en nombres entiers. Ils sont en virgule flottante, ou réels. Nous pouvons assigner des valeurs aux variables en utilisant l'opérateur = .
>
x = 7
> print(x)
7
La variable x est créée quand le numéro 7 lui est assigné. Nous
employons la
fonction print() pour imprimer la valeur de x.
Nous pouvons maintenant employer la valeur de x pour d'autres
calculs.
> x = x * 9
> print(x)
63
> print(x*2) -- ne changeront pas la valeur
de x
126
>print(x)
63
Remarquez la façon dont print(x*2) ne change pas la
valeur x parce qu'elle n'a pas été assignée avec l'opérateur = mais avec x
= x * 9, opération qui multiple la valeur courante de x par 9 et
stocke la nouvelle valeur dans x.
Pour plus d'information sur lse types du nombre de Lua vous pouvez regarder le chapître Nombres.
Lua emploie également des chaînes de caractères ou variables de type texte :
> print("hello")
hello
Nous pouvons assigner des chaînes de caractères aux variables comme nous l'avons fait avec des nombres :
> who = "Lua user" > print(who) Lua user
Nous pouvons concaténer (assembler) des chaînes de caractères employant l'opérateur .. entre deux chaînes de caractères .
> print("hello ") hello
> print("hello " .. who) -- the variable "who" was assigned above
hello Lua user
> print(who) Lua user
Notez que l'opérateur
.. ne change pas
la valeur de la variable who à moins que l'opérateur d'assignation = ne soit employé.
> message = "hello " .. who
> print(message) hello
Lua user
À la différence d' autres langages, vous ne
pouvez pas employer l'opérateur + pour concaténer des
chaînes de caractères c.-à-d. :
> message = "hello " + who
stdin:1: attempt to perform arithmetic on a string value
stack traceback:
stdin:1: in main chunk
[C]: ?
Lua a également un type de donnée d'usage universel appelé une table. Des Table
peuvent être employés pour stocker des groupes d'objets. Vous pouvez stocker
des nombres, ou des chaînes de caractères , ou d'autres tables
dans les tables. Des Table sont créés en utilisant une paire de parenthèses
bouclées {} .
Créons une table vide :
>x = {}
>print(x)
table
: 0035C910
(il est normal si votre table n'a pas la même identifiant unique comme dans l'exemple ci-dessus.)
Quand nous affichons la valeur d'une variable de table en employant la
fonction print, Lua affiche juste le fait que la variable est une table, et l'identifiant
unique de cette table (c.-à-d. son adresse dans la mémoire). Nous pouvons
imprimer le contenu d'une table mais cela sera expliqué dans le chapître Table.
Nous pouvons construire des tables contenant d'autres objets, tels que des nombres et des chaînes de caractères comme décrits ci-dessous dans cet exemple.
> x = { value = 123, text = "hello" }
> print(x.value)
123
> print(x.text)
hello
Nous pouvons imprimer les valeurs en employant la notation table.item. Nous pouvons également mettre des tables à l'intérieur d'autres tables.
Voici le cas d'une table à 2 dimensions.
> y = { const={ name="Pi", value=3.1415927 }, const2={ name="light speed", value=3e8 } }
> print(y.const.name)
Pi
> print(y.const2.value)
300000000
Les valeurs booléennes ont soit la valeur true soit la valeur false.
Si une valeur n'est pas true, elle doit être false et
vice versa.L'opérateur not peut être placé avant une valeur booléenne
pour l'inverser c.-à-d.. not true est égal à false.
> x = true > print(x)
true
> print(not x)
false
> print(not false)
true
Des valeurs booléennes sont employées pour
représenter les résultats de tests logiques. Les operateurs de comparaison égale = =,
et différent ~ = renverront des valeurs booléennes selon les valeurs qu'ils comparent.
> print(1 == 0) -- test whether two numbers are equal false > print(1 == 1) true > print(1 ~= 0) -- test whether two numbers are not equal true > print(true ~= false) -- is true not equal to false? true
Dans Lua, des fonctions sont assignées aux variables, juste comme des nombres
et des chaînes de caractères . Des fonctions
sont créées en utilisantle mot-clé function.
Ci-après nous créons une fonction simple qui imprimera un message d'hello.
> function foo() print("hello") end -- declare the function
> foo() -- call the function
hello
> print(foo) -- get the value of the variable "foo"
function: 0035D6E8
Remarque: nous pouvons imprimer la valeur de la variable foo et
(comme pour les tables) nous avons en retour son identifiant unique (son adresse en mémoire). Ainsi, une fonction étant
une variable nous pouvons assigner des fonctions
aux variables, comme pour les autres variables, ce qui donne.
> x = function() print("hello") end
> x()
hello
> print(x)
function: 0035EA20
La capacité à faire ceci est lié aux valeurs de premières classe. Ceci signifie que toutes les valeurs sont traitées de la même manière. C'est un dispositif très puissant et utile de Lua.
Vous pourriez avoir noté que tandis que nous créions les variables ci-dessus, nous n'avons pas dû indiquer quel type de variable nous créions.
Par exemple,
a = 1
b = "hello"
c = { item1="abc" }
Dans d'autres langages, telles que C, nous devons indiquer le type d'une variable quand nous la créons. De même que nous n'avons pas besoins de spécifier quel type a une variable particulière on peut également assigner différents types de valeur à la même variable, par exemple.
a = 1
a = "hello"
a = { item1="abc" }
Ceci s'appelle typage dynamique. Ceci signifie que vous ne devez pas indiquer quel type a une variable. La variable connaît son type en fonction de la valeur ou de l'objet qui lui a été assigné.
C'est une valeur spéciale qui signifie qu'une variable n'a aucune valeur.
Si une variable a la valeur nil elle n'a aucune
valeur assignée et donc elle 'existe pas encore. En plaçant une variable nil vous
pouvez supprimer une variable par exemple.
> x = 2.5
> print(x)
2.5
> x = nil
> print(x)
nil
Vous pouvez vérifier qu'une variable existe en comparant sa
valeur à nil.
> print(x == nil)
true
> x = 7
> print(x == nil)
false
> print(x)
7
Comme LUA est un language reflectif, nous pouvons utilisé la fonction type() pour obtenir le type d'une variable particulière.
> x = "123" -- une chaîne de caractères
> print(x, type(x)) -- affiche la valeur de x et son type
123 string
> x = x + 7 -- ajoute un nombre à la chaîne et force son typage (coercition)
> print(x, type(x)) -- again show the value and type
130 number
 www.loriotpro.com |
|