|
Documentation language LUA |
Tableaux |
Les Tableaux sont des type de variables très flexibles
et utiles dans Lua. Cette page est une introduction à l'utilisation des tableaux.
Lua a une bibliothèque de table 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 tableaux pour découvrir ces fonctions sur les tableaux en détails.
Les tableaux 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, seulement 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 Tableaux peuvent être employés pour contenir des jeux de variables. Les constructeurs de Tableau peuvent contenir une liste d'objets séparée 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
Employer des constructeurs de table est un 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
rangée de table en utilisant table.insert(table,value) la fonction.
> 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 bibliothèque de table pour insérer des éléments dans la rangée de table
sans mélanger les autres éléments contigus. Pour faire
ceci nous fournissons 3 arguments table.insert(table,position,value) à la
fonction. 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 Tableaux 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, tableaux associatifs, liste
indexé,
ou associations typées. Nous
emploierons le terme dictionnaire quand un élément du tableux a une
index et une valeur.
La index est employée
pour affecter et rechercher une valeur d'un élément de tableau.
Nous pouvons employer le table[key ] = format de
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 index-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 index dans une table.
Remarque, il n'y a
aucune garantie
quant à l'ordre dans lequel des index seront stockées dans une table quand
on utilise des dictionnaires ainsi l'ordre de la
récupération d'employer de index 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
Table.key = format de valeur est une syntaxe possible pour table["key" ] = valeur
quand la index 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 index 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 ensemblex, 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 numbers/strings, 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) l'information
différente d'expositions dans les deux cas.
Lua stocke tous les éléments dans les tables génériquement comme paires de index-valeur. Lua ne différencie pas entre les rangées et les dictionnaires. Toutes les tables de Lua sont réellement des dictionnaires. Dans une rangée les index sont des index d'objet 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 |
|