Variables Lua

Avant d'utiliser une variable, il est nécessaire de la déclarer dans le code, c'est-à-dire de créer cette variable.

Avant d'exécuter le code, le compilateur Lua doit savoir comment allouer de l'espace de stockage pour les variables des instructions, utilisé pour stocker les valeurs des variables.

Les variables Lua ont trois types : variables globales, variables locales, et zones de table.

Dans Lua, toutes les variables sont des variables globales, même si elles sont dans un bloc de statement ou une fonction, sauf si elles sont explicitement déclarées comme variables locales en utilisant local.

La portée des variables locales commence à partir de la position de déclaration et se termine à la fin du bloc de statement.

La valeur par défaut de chaque variable est nil.

--　Fichier de script test.lua
a =　5　　　　　　　　　　　　　　　--　Variables globales
local b =　5　　　　　　　　　--　Variables locales
function joke()
　　　　c =　5　　　　　　　　　　　--　Variables globales
　　　　local d =　6　　　　　--　Variables locales
end
joke()
print(c, d)　　　　　　　　　　-->　5　nil
do　
　　　　local a =　6　　　　　--　Variables locales
　　　　b =　6　　　　　　　　　　　--　Réaffectation des variables locales
　　　　print(a, b);　　　　　-->　6　6
end
print(a,b)　　　　　　-->　5　6

Le résultat de l'exécution de l'exemple ci-dessus est :

$ lua test.lua　
5　　　　nil
6　　　　6
5　　　　6

Instruction d'affectation

L'affectation est la méthode la plus fondamentale pour changer la valeur d'une variable et modifier une zone de table.

a = "hello" .. "world"
t.n = t.n　+　1

Lua peut affecter plusieurs variables en même temps, les éléments de la liste des variables et des valeurs sont séparés par des virgules, et les valeurs à droite de l'instruction d'affectation sont assignées aux variables à gauche dans l'ordre.

a, b =　10,　2*x <--> a =10; b =2*x

Lorsqu'il rencontre une instruction d'affectation, Lua calcule d'abord toutes les valeurs à droite avant d'exécuter l'opération d'affectation, donc nous pouvons échanger les valeurs des variables de cette manière :

x, y = y, x　　　　　　　　　　　　　　　　　　　　　--　swap　'x'　for　'y'
a[i],　a[j]　=　a[j],　a[i]　　　　　　　　　--　swap　'a[i]'　for　'a[j]'

Lorsque le nombre de variables et de valeurs ne correspond pas, Lua adopte la stratégie suivante en se basant sur le nombre de variables :

a.　Nombre de variables　>　Nombre de valeurs　　　　　　　　　　　　　Les valeurs manquantes seront complétées par nil
b.　Nombre de variables　<　Nombre de valeurs　　　　　　　　　　　　　Les valeurs en excès seront ignorées

a,　b,　c　=　0,　1
print(a,b,c)　　　　　　　　　　　　　-->　0　　　1　　　nil
　
a,　b　=　a+1,　b+1,　b+2　　　　　--　value　of　b+2　is　ignored
print(a,b)　　　　　　　　　　　　　　　-->　1　　　2
　
a,　b,　c　=　0
print(a,b,c)　　　　　　　　　　　　　-->　0　　　nil　　　nil

Le dernier exemple ci-dessus est une situation d'erreur courante, notez : pour affecter à plusieurs variables, il est nécessaire de les affecter une à une.

a,　b,　c　=　0,　0,　0
print(a,b,c)　　　　　　　　　　　　　-->　0　　　0　　　0

L'assignment multiple est souvent utilisé pour échanger des variables ou pour affecter des valeurs de retour à des variables :

a,　b　=　f()

f() retourne deux valeurs, la première assignée à a, la deuxième à b.

Il convient de préférer les variables locales, qui ont deux avantages :

• 1. Éviter les conflits de noms.

• 2. L'accès aux variables locales est plus rapide que celui des variables globales.

Index

L'index d'une table s'effectue avec des crochets [] et Lua propose également l'opérateur .

t[i]
t.i　　　　　　　　　　　　　　　　　--　Une écriture simplifiée lorsque l'index est de type chaîne
gettable_event(t,i)　--　L'accès par index est essentiellement une appelle de fonction similaire

>　site　=　{}
>　site["key"]　=　"fr.oldtoolbag.com"
>　print(site["key"])
fr.oldtoolbag.com
>　print(site.key)
fr.oldtoolbag.com