Un des plus grands intérêts de Lua réside dans l’utilisation des tables. Attention toutefois, certains pièges sont à connaître.
Première partie
Création basique d’une table
1
2
3
4
5
6
7
8
9
|
a = {}
print(a)
-- Attention, la sortie variera selon votre système.
-- Elle représente l'adresse mémoire où la table est stockée.
-- Ce résultat n’est utile que pour indiquer que la table existe.
-- output:
-- table: 0x380
|
Taille d’une table
1
2
3
4
5
|
a = {}
print(#a)
-- output:
-- 0
|
Ajout d’éléments
1
2
3
4
5
6
7
8
9
10
11
|
a = {}
a[1] = 5 -- méthode directe par indice
table.insert(a, 8) -- ajout automatique à la fin
print(a[1])
print(a[2])
print("Taille de la table: " .. #a)
-- output:
-- 5
-- 8
-- Taille de la table: 2
|
Remplissage et parcours avec for
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
maTable = {}
for i = 1, 5 do
table.insert(maTable, i + 1)
end
print("Taille de la table: " .. #maTable)
for i = 1, #maTable do
print(maTable[i])
end
-- output:
-- Taille de la table: 5
-- 2
-- 3
-- 4
-- 5
-- 6
|
Table avec des éléments prédéfinis
1
2
3
4
5
6
7
8
9
10
11
|
a = {6, "cinq", 5}
print(#a)
for i = 1, #a do
print(a[i])
end
-- output:
-- 3
-- 6
-- cinq
-- 5
|
Parcours avec ipairs
1
2
3
4
5
6
7
8
9
|
maTable = {}
for i = 1, 5 do
table.insert(maTable, i + 1)
end
for i, val in ipairs(maTable) do
print("Indice: " .. i)
print("Valeur: " .. val)
end
|
Variante en ignorant l’indice
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
maTable = {}
for i = 1, 5 do
table.insert(maTable, i + 1)
end
for _, val in ipairs(maTable) do
print(val)
end
-- output:
-- 2
-- 3
-- 4
-- 5
-- 6
|
Suppression d’un élément
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
a = {"un", "deux", "deux", "quatre", "quatre", "cinq"}
val = table.remove(a, 1)
print("Valeur supprimée: " .. val)
table.remove(a, #a)
for i = 1, #a do
print(a[i])
end
-- output:
-- Valeur supprimée: un
-- deux
-- deux
-- quatre
-- quatre
|
Fusion d’une liste
1
2
3
4
5
6
7
8
9
10
|
a = {"Hello", "world", "!"}
chaine = table.concat(a, " ")
print(chaine)
a = {1, 2, 3, 4, 5}
print(table.concat(a, " "))
-- output:
-- Hello world !
-- 1 2 3 4 5
|
Deuxième partie
Utiliser des chaînes comme clés
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
maTable = {}
maTable["var"] = 1
maTable["autreChaine"] = "texte"
for key, value in pairs(maTable) do
print("Clef: " .. key)
print("Valeur: " .. value)
end
-- output:
-- Clef: var
-- Valeur: 1
-- Clef: autreChaine
-- Valeur: texte
|
Table initialisée directement
1
2
3
4
5
6
|
a = {var = 1, autreChaine = "texte"}
for key, value in pairs(a) do
print("Clef: " .. key)
print("Valeur: " .. value)
end
|
Accès aux valeurs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
maTable = {}
maTable["var"] = 1
maTable["autreChaine"] = "texte"
print(maTable["var"])
print(maTable.var)
print(maTable["autreChaine"])
print(maTable.autreChaine)
-- output:
-- 1
-- 1
-- texte
-- texte
|
Résumé :
pairs() : pour les tables avec clés personnalisées.ipairs() : pour les tables indexées numériquement.
Les pièges
Indexation à partir de 1
1
2
3
4
|
a = {}
table.insert(a, 6)
print(a[0]) -- nil
print(a[1]) -- 6
|
Accès incorrect aux clés dynamiques
1
2
3
4
5
|
maTable = {var = 1, autreChaine = "texte"}
for k, v in pairs(maTable) do
print(maTable.k) -- incorrect, renvoie nil
end
|
Taille incorrecte avec des clés
1
2
3
4
5
|
maTable = {var = 1, autreChaine = "texte"}
print("Taille de la table: " .. #maTable)
-- output:
-- Taille de la table: 0
|
Valeurs non consécutives
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
a = {}
a[1] = 5
a[2] = 5
a[4] = 5
print("Taille de la table: " .. #a)
for i = 1, #a do
print(a[i])
end
-- output:
-- Taille de la table: 4
-- 5
-- 5
-- nil
-- 5
|
Trous plus grands encore
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
a = {}
a[1] = 5
a[2] = 5
a[5] = 5
print("Taille de la table: " .. #a)
for i = 1, #a do
print(a[i])
end
-- output:
-- Taille de la table: 2
-- 5
-- 5
|