|
Programmation en language LUA | |
Tables de variables |
Les Tables de variables sont des types de variables très flexibles
et très utiles dans la programmation Lua. Cette page est une introduction à l'utilisation des Tables de variables.
Lua propose une bibliothèque de fonctions de manipulation des tables pour compléter son type de variable table.
Les exemples visibles sur cette page utilisent la bibliothèque de table standard. Reportez vous à Fonctions sur les Tables pour découvrir ces fonctions sur les Tables en détails.
Les Table sont créés en utilisant les constructeurs de table, qui
sont
définis à l'aide des parenthèses ouverte et fermée, par exemple. {
} .
Pour
définir
une table vide nous procéderons comme ci-dessous.
> t = {} -- construction d'une table vide et affectation
à la variable "t"
>
print(t)
table: 0035AE18
Remarque: quand la valeur d'une variable table est affichée, seuls le type et son identifiant unique (ID) de l'objet sont affichés. De façon à afficher le contenu d'une table nous devons faire cela explicitement.
Des Tables peuvent être employées pour contenir des jeux de variables. Les constructeurs de Tables peuvent contenir une liste d'objets séparées par virgule pour créer une rangée. Les éléments de rangée peuvent être consultés en utilisant les crochets, le table[index ]. par exemple :
> t = { 1,1,2,3,5,8,13 }
>
print( t[1] )
1
>
print( t[0] )
nil
>
print( t[4] )
3
Notez que l'indexation dans la rangée commence à 1, pas à zéro. t[0] a
la valeur nil, c.-à-d. il
n'y a aucun élément à la position 0. t = { 1,1,2,3,5,8,13 }
La ligne est équivalente à ce qui suit :
> t = {}
>
t[1]=1 t[2]=1 t[3]=2 t[4]=3 t[5]=5 t[6]=8 t[7]=13
L'emploi des constructeurs de table est un peu plus lisible et est moins générateur d'erreur.
Nous pouvons trouver la taille d'une table en utilisant la
fonction de bibliothèque de table standard table.getn() (c.-à-d.
obtenez le nombre d'éléments)
> = table.getn(t)
7
Nous pouvons ajouter de nouveaux éléments dans
une rangée de table en utilisant la fonction table.insert(table,value).
> table.insert(t,21)
>
= table.getn(t)
8
>
= t[7], t[8]
13 21
Nous pouvons également insérer
des éléments à un endroit choisi dans la table. Nous pouvons employer
la fonction table.insert pour insérer des éléments dans la rangée de table
sans mimpact sur les autres éléments contigus. Pour faire
ceci nous fournissons 3 arguments à la
fonction table.insert(table,position,value) . Nous pouvons également employer table.remove(table,position) pour
enlever des éléments d'une rangée de table.
> table.insert(t,4,99)
>
= t[3], t[4], t[5]
2 99 3
>
table.remove(t,4)
>
= t[3], t[4], t[5]
2 3 5
Nous pouvons montrer les éléments contenus
dans
une rangée en utilisant table.foreachi(table,function) la fonction.
Ceci applique
la fonction passée à chaque élément de la rangée, dans l'ordre d'index. Par
exemple, si nous passons la table ci-dessus et print() la fonction
nous obtenons le resultat suivant.
> table.foreachi(t,print)
1 1
2 1
3 2
4 3
5 5
6 8
7 13
8 21
Notez que nous ne sommes pas limités à stocker un type de données dans une rangée. Nous pouvons insérer des nombres, chaînes de caractères , fonctions, ou d'autres tables, par exemple.
> t[4] = "three"
>
t[6] = "eight"
>
t[2] = { "apple", "pear", "banana" }
>
table.foreachi(t,print)
1 1
2 table: 0035DFE8
3 2
4 three
5 5
6 eight
7 13
8 21
Des Tables peuvent également être employés pour stocker l'information qui n'est pas classée numériquement, ou séquentiellement, comme avec des rangées.
Ces types de
stockage parfois s'appellent les dictionnaires, Table associatifs, liste
indexé,
ou associations typées. Nous
emploierons le terme dictionnaire quand un élément du table a une clé et une valeur.
La clé est employée
pour affecter et rechercher une valeur d'un élément de table.
Nous pouvons employer le format table[key ] = valeur pour insérer des éléments dans la table. Une clé n'a pas besoin d'être un nombre, ce peut être une chaîne de caratères, ou de même n'importe quel autre objet de Lua. Construisons une table avec quelques paires de clé-valeur :
> t = { apple="green", orange="orange", banana="yellow" }
>
table.foreach(t,print)
apple green
orange orange
banana yellow
Notez que nous devons employer table.foreach(table,function) la
fonction, plutôt que table.foreachi(table,function) pour produire
les valeurs.
C'est parce que les index ne sont plus des nombres et table.foreachi() la
fonction réitère à partir des
index dans une table, tandis que table.foreach() la fonction
réitère à partir des clés dans une table.
Remarque, il n'y a
aucune garantie
quant à l'ordre dans lequel les clés seront stockées dans une table quand
on utilise des dictionnaires ainsi l'ordre de la
récupération avec la fonction table.foreach() n'est pas garanti,
par
exemple.
> t.melon = "green"
>
t["strawberry"] = "red"
>
table.foreach(t,print)
melon green
strawberry red
apple green
orange orange
banana yellow
Le format Table.key = valeur est une syntaxe possible pour l'expression table["key" ] = valeur
quand la clé est une chaîne de caractères,
c.-à-d.. t.apple est peu un plus lisible que t["apple"].
Cette syntaxe rend Lua plus lisible. Dans l'exemple
ci-dessus :
> t = { apple="green", orange="orange", banana="yellow" }
est le même que :
> t = { ["apple"]="green", ["orange"]="orange", ["banana"]="yellow" }
Notez que si notre clé contient un espace que nous devons employer [ "format de key"]=value :
> t = { ["keys can contain more than one word"] = "as a
string can contain any characters" }
>
t["another string"] = 99
Vous n'êtes pas limité à employer des constructeurs de table en tant que listes séquentiellement indexées, ou comme dictionnaires, vous pouvez également mélanger les deux ensemble, par exemple,
> t = {2.4.6, language="Lua", version="5"}
Ici nous avons un choix de nombres suivis de quelques valeurs de dictionnaire. Nous pouvons employer nos fonctions de bibliothèque de table de Lua pour afficher le contenu de la table.
> table.foreach(t,print)
1 2
2 4
3 6
language Lua
version 5
>
table.foreachi(t,print)
1 2
2 4
3 6
Remarquez comment les sorties diffèrent. table.foreachi() a
seulement affiché le contenu numériquement indexé et table.foreach() a
affiché tout le contenu. Nous pouvons utiliser les deux modèles
syntaxique à volonté :
> t = {2.4.6, language="Lua", version="5", 8.10.12, web="www.lua.org"}
En raison de la coercition de nombre/chaînes, faîtes attention quand vous affichez des index. Par exemple :
t = {}; t[1] = "a"; t["1"] = "b"
> for k,v in pairs(t) do print(k,v) end
1 a
1 b
Naturellement, type(k) affiche des informations
différentes dans les deux cas.
Lua stocke tous les éléments dans les tables génériquement comme paires de key-valeur. Lua ne différencie pas entre les tables en rangées avec index numériques et les dictionnaires. Toutes les tables de Lua sont réellement des dictionnaires. Dans une rangée les index sont des objets clé de type nombre.
t = { 3,6,9 } -- is the same as...
> t = { [1]=3, [2]=6, [3]=9 } -- is the same as...
> t = {} t[1]=3 t[2]=6 t[3]=9
Notez que les index sont des références aux objets ainsi vous devez employer la même référence pour entrer le même index dans la table. Vous pouvez employer n'importe quel objet de Lua comme index dans une table. Nous pouvons démontrer que les index sont des références aux objets en employant une table comme index :
> a = {[ {1,2,3}]="yadda"} -- construisez une table où l'élément a une
index de table
> table.foreach(a, print) -- affiche le contenu de table : par de
index-valeur
table : 0035BBC8 yadda
> = a[{1,2,3} ] -- affiche la
valeur d'élément
nil
Ceci n'a pas fonctionné parce que quand nous
avons essayé de rechercher la valeur a[{1,2,3}] nous avons construit
une autre table, c.-à-d. que la table que nous avons employée comme index
dans le constructeur de table n'est pas la même que celui que nous avons utilisé
pour accéder à la valeur. Si nous employons la
même table dans les deux cas cela fonctionnera :
> tablekey = {1,2,3} -- create a table with a variable referencing it
>
a = { [tablekey]="yadda" } -- construct a table using the table as
a key
>
table.foreach(a,print) -- display the table elements
table: 0035F2F0 yadda
>
= a[tablekey] -- retrieve a value from the table
yadda
>
print(tablekey) -- the table value is the same as the key above
table: 0035F2F0
Du fait que les index sont des références, et que des chaînes de caractères peut être employé, nous allons aborder le fonctionnement interne de Lua. Nous devons nous référer à la même chaîne de caractères sinon quand nous accédons et affectons les index de table (valeur ou chaîne de caractères) cela ne fonctionneraient pas ! Des chaînes de caractères ne sont pas reproduites dans Lua intérieurement, ainsi quand vous mettez en référence une chaîne de caractères avec la même valeur cellec-ci se rapportent à la même chaîne de caractères.
> t = { apple=5 }
>
a = "apple"
>
b = "apple"
>
print(t.apple, t[a], t[b]) -- all the same value because there is only one "apple"!
5 5 5
Pour démontrer que nous pouvons employer tous les objets de Lua comme index :
> t = { [function(x) print(x) end] = "foo" }
>
for key,value in next,t do key(value) end
foo
La fonction anonyme prend un argument simple, qu'elle affiche et a la valeur "foo". La lecture de la table par itération de l'index index (c.-à-d. fonction) en lui passant la valeur de la fonction, et affiche : "foo".
 www.loriotpro.com |
|