Programmation en language LUA

Table des matières

HelpLUA

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.

Créer une table

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.

Table en tant que rangé avec index numérique

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

Table comme dictionnaires

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

Constructeurs mélangés de table

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.

Notes au sujet des index de table

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

chaînes de caractères comme références

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

Quelque chose comme index

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".



LUTEUS