Variables Lua

Avant qu'une variable soit utilisée, elle doit être déclarée dans le code, c'est-à-dire que la variable doit être créée.

Avant d'exécuter le code, le compilateur doit savoir comment allouer de l'espace de stockage pour les variables d'instruction afin de stocker leurs valeurs.

Les variables Lua ont trois types : les variables globales, les variables locales et les champs dans les tables.

Toutes les variables en Lua sont des variables globales, même dans les blocs d'instructions ou les fonctions, sauf si elles sont explicitement déclarées comme variables locales à l'aide de `local`.

La portée d'une variable locale s'étend de la position de sa déclaration jusqu'à la fin du bloc d'instructions dans lequel elle se trouve.

La valeur par défaut des variables est nil.

Exemple

-- script du fichier test.lua
a = 5               -- Variable globale
local b = 5         -- Variable locale

function joke()
    c = 5           -- Variable globale
    local d = 6     -- Variable locale
end

joke()
print(c,d)          --> 5 nil

do
    local a = 6     -- Variable locale
    b = 6           -- Réaffecter la variable locale
    print(a,b);     --> 6 6
end

print(a,b)      --> 5 6

L'exécution de l'exemple ci-dessus produit la sortie suivante :

$ lua test.lua 
5    nil
6    6
5    6

Instruction d'affectation

L'affectation est la façon la plus élémentaire de modifier la valeur d'une variable et de modifier un champ de table.

a = "hello" .. "world"
t.n = t.n + 1
Lua peut affecter des valeurs à plusieurs variables en même temps. Les éléments de la liste de variables et de la liste de valeurs sont séparés par des virgules. Les valeurs du côté droit de l'instruction d'affectation sont affectées aux variables de gauche dans l'ordre.
a, b = 10, 2*x       <-->       a=10; b=2*x

Lorsqu'il rencontre une instruction d'affectation, Lua évalue d'abord toutes les valeurs de droite puis effectue l'opération d'affectation, nous pouvons donc échanger les valeurs des variables de cette façon :

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 le nombre de valeurs ne correspondent pas, Lua prend toujours le nombre de variables comme base et adopte la stratégie suivante :

a. 变量个数 > 值的个数             按变量个数补足nil
b. 变量个数 < 值的个数             多余的值会被忽略

Exemple

a, b, c = 0, 1
print(a,b,c)             --> 0   1   nil
 
a, b = a+1, b+1, b+2     -- la valeur de b+2 est ignorée
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. Remarque : si vous voulez affecter des valeurs à plusieurs variables, vous devez affecter chaque variable à tour de rôle.

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

L'affectation multiple est souvent utilisée pour échanger des variables ou pour affecter les valeurs de retour d'un appel de fonction à des variables :

a, b = f()

f() renvoie deux valeurs, la première est affectée à a, et la seconde est affectée à b.

Vous devriez utiliser des variables locales autant que possible. Il y a deux avantages :

  • 1. Évitez les conflits de nommage.
  • 2. L'accès aux variables locales est plus rapide que l'accès aux variables globales.

Indexation

Utilisez des crochets [] pour indexer les tables. Lua fournit également l'opération .

t[i]
t.i                 -- 当索引为字符串类型时的一种简化写法
gettable_event(t,i) -- 采用索引访问本质上是一个类似这样的函数调用

Exemple

> site = {}
> site["key"] = "www.example.com"
> print(site["key"])
www.example.com
> print(site.key)
www.example.com
Autres extensions