|
Programmation en language LUA | |
Fonctions des tables |
Ce document présente les fonctions de manipulation de tables en LUA. Ces fonctions peuvent être utilisées dans les scripts LUA de LoriotPro.
Voici la liste préliminaire de description des fonctions de manipulation des tables:
La plupart des fonctions des Table supposent que les Tables représentent une rangée ou une liste. Pour ces fonctions, un concept important est la taille de la rangée.
Il y a trois manières d'indiquer cette taille :
n" - quand la table a un champ
"n" avec une valeur numérique, cette valeur est assumée
en tant que sa taille.setn - vous pouvez appeler table.setn() la fonction pour placer
explicitement la taille d'une table.nil. Pour plus de détails, voyez les descriptions du table.getn() et table.setn() des fonctions.
Note : La taille d'une table ne reflète pas nécessairement le nombre d'éléments contenus dans la table. Ceci peut sembler un peu étrange mais cela peut être utile, par exemple, pour maintenir les listes non séquentielles.
Concatène les éléments d'une table ensemble
pour former une chaîne de caractères. Chaque élément doit pouvoir être
converti dans une chaîne de caractères. On peut indiquer un séparateur qui
est placé entre les éléments enchaînés. En plus une foruchette d'élément
peut être indiquée dans la table, commençant i-
élémentet pour finir au j-élément.
> = table.concat({ 1, 2, "three", 4, "five" })
12three4five
> = table.concat({ 1, 2, "three", 4, "five" }, ", ")
1, 2, three, 4, five
> = table.concat({ 1, 2, "three", 4, "five" }, ", ", 2)
2, three, 4, five
> = table.concat({ 1, 2, "three", 4, "five" }, ", ", 2, 4)
2, three, 4
Nous ne pouvons pas concaténer des tables contenant des tables parce qu'elles ne peuvent pas être converties en chaînes de caractères . Consultez la section sur les chaînes de caractères pour plus d'information sur la coercition.
> = table.concat({ 1,2,{} })
stdin:1: bad argument #1 to `concat' (table contains non-strings)
stack traceback:
[C]: in function `concat'
stdin:1: in main chunk
[C]: ?
(Cette fonction est obsolete depuis LUA 5.1) Lopérateur pairs() doit être utilisé à la place.
Applique la fonction f aux
éléments de la table. Sur chaque itération est passée la paire de clef-valeur de cet élément dans la table à la
fonction f
> table.foreach({1,"two",3}, print)
-- print the key-value pairs
1 1
2 two
3 3
> table.foreach({1,"two",3,"four"}, function(k,v)
print(string.rep(v,k)) end)
1
twotwo
333
fourfourfourfour
Si la fonction f renvoie une valeur a non-nil la boucle
d'itération se termine.
> table.foreach({1,"two",3}, function(k,v)
print(k,v) return k<2 and nil end)
1 1
2 two
Les Tables peuvent contenir des éléments mélangés de clef-valeur et d'index-valeur. table.foreach() montrera tous les éléments dans une table. Pour
montrer seulement les éléments d'index-valeur consultez la fonction table.foreachi(). Pour plus
d'informations sur ce sujet voyez la section sur les
Tables.
> t = { 1,2,"three"; pi=3.14159, banana="yellow" }
> table.foreach(t, print)
1 1
2 2
3 three
pi 3.14159
banana yellow
(Cette fonction est obsolete depuis LUA 5.1) Lopérateur ipairs() doit être utilisé à la place.
Applique la fonction f aux
éléments de la table passée. Sur chaque itération la
fonction f est passée la paire d'index-valeur de cet élément dans la table.
Cette fonction est semblable à table.foreach() sauf que des
paires d'index-valeur sont utilisées et pas des paires de clef-valeur.
Si la fonction f renvoie a non-nil la boucle d'itération se
termine.
> t = { 1,2,"three"; pi=3.14159, banana="yellow" }
> table.foreachi(t, print)
1 1
2 2
3 three
A noter que dans l'exemple ci-dessus seules les éléments indexés de la table sont affichés. Consultez la section sur les Tables pour plus d'information sur les paires de clef-valeur et d'index-valeur.
Ceci est employé pour déterminer la taille d'une table. La taille d'une table est abordée début de document.
> = table.getn({1,2,3}) -- Lua comptera les éléments si
aucune taille n'est indiquée
3
> = table.getn({1,2,3 ; n=10})
-- n dépasse le nombre d'éléments déclarés
10
> t = {1.2.3} >
table.setn(t, 10) -- définir notre propre taille avec le setn()
> =
table.getn(t)
10
> = table.getn({1,2,3,nil,5,6}) -- fin de table à l'élément 3 dû à la valeur nil en 4
3
Tri les éléments d'une table et modifie l'ordre des élément dans celle-ci.
> t = { 3,2,5,1,4 }
> table.sort(t)
> = table.concat(t, ", ") -- display sorted values
1, 2, 3, 4, 5
Si la table a une taille indiquée seulement la
fourchette d'éléments indiquée est triée, par exemple,
> t = { 3,2,5,1,4; n=3 }
-- construct a table with user size of 3
> table.sort(t) -- sort will be limited by user size
> = table.concat(t, ", ")
-- only specified size is concatenated as well
2, 3, 5
Une fonction de comparaison peut être fournie
pour définir le tri des éléments. La fonction de comparaison
doit renvoyer une valeur booléenne indiquant si le premier argument
devrait être avant le deuxième argument dans l'ordre de tri. Le
comportement par défaut est pour quela comparaison < soit
faite. Par exemple, ce qui suit se comporte comme si aucune
fonction nétait fournie :
> t = { 3,2,5,1,4 }
> table.sort(t, function(a,b) return a<b end)
> = table.concat(t, ", ")
1, 2, 3, 4, 5
Nous constatons que si nous changeons la fonction de comparaison ,l'ordre de tri est renversé.
> table.sort(t, function(a,b) return a>b end)
> = table.concat(t, ", ")
5, 4, 3, 2, 1
Insére une valeur donnée dans une table. Si une position est donnée l'insertion se fait avant l'élément actuellement à cette position :
> t = { 1,3,"four" } > table.insert(t, 2, "two") -- insert "two" at position before element 2
> = table.concat(t, ", ")
1, two, 3, four
Si aucune position n'est indiquée l'insertion est réalisée à l'extrémité de la table :
> table.insert(t, 5) -- no position given so append to end
> = table.concat(t, ", ")
1, two, 3, four, 5
Quand une table a un élément à insérer, la taille de la table et les index d'éléments sont mis à jour :
> t = { 1,"two",3 } -- create a table
> = # t -- find current size
3
> table.foreach(t, print) -- display the table contents
1 1
2 two
3 3
> table.insert(t, 1, "inserted")
-- insert an element at the start > = table.concat(t, ", ")
-- see what we have inserted, 1, two, 3
> = # t -- find the size 4 > table.foreach(t, print)
-- the indexes have been updated
1 inserted
2 1
3 two
4 3
Quand aucune position n'est indiquée, l'élément est inséré à l'extrémité de la table selon la taille calculée. La taille d'une table peut être indiqué et ne pas refléter le nombre d'éléments, par exemple,
> t = { 1,"two",3; n=10 } -- create a table with user size
> table.insert(t, "end") -- insert with no position inserts at "end"
> table.foreach(t, print) -- display the table contents
1 1
2 two
3 3
11 end
n 11
Enlevez un élément d'une table. Si une position est indiquée, l'élément à cette position est enlevée. Les éléments restants sont réindexés séquentiellement et la taille de la table est mise à jour pour refléter le changement. L'élément enlevé est retourné par cette fonction. Par exemple,
> t = { 1,"two",3,"four" } -- create a table
> = # t -- find the size 4
> table.foreach(t, print) -- have a look at the elements
1 1
2 two
3 3
4 four
> = table.remove(t,2) -- remove element number 2 and display it two
> table.foreach(t, print) -- display the updated table contents
1 1
2 3
3 four
> = # t -- find the size
3
Si aucune position n'est donnée, cela enleve le dernier élément dans la table qui est indiquée par la taille de la table. Par exemple,
> t = { 1,"two","three" }
> = # t -- find the table size (which is removed)
3
> table.foreach(t, print) -- display contents
1 1
2 two
3 three
> = table.remove(t) -- remove the element at position "n" three
> table.foreach(t, print) -- display updated contents
1 1
2 two
> = # t -- display new size
2
Si la taille de la table ne reflète pas le nombre d'éléments rien n'est enlevé, par exemple,
> t = {1,2,3} > table.setn(t,10) -- set user size
> table.foreach(t, print) -- display table contents, note size "n" is stored internally
1 1
2 2
3 3
> = # t -- find the size
10
> = table.remove(t) -- remove last element nil
> = # t -- find the updated size
9
> table.foreach(t, print) -- display elements
1 1
2 2
3 3
Définir la taille d'une table (voir les notes sur
la taille de table en début de page). Si la table a
une valeur "n" elle est mise à jour, par exemple,
> t = {1, "two", "trois" ; n=10} -- créez
une table qui a une taille d'utilisateur indiquée
> = table.getn(t)
-- a lu la taille 10
> table.foreach(t, copie) -- montrez les éléments du tableau
1 1
2 deux
3 trois n 10
> table.setn(t, 12) --
emploie le setn pour changer la taille
> = table.getn(t) -- montrez la taille
12
> table.foreach(t, copie) -- montre le contenu
1 1
2 deux
3 trois
n 12
Si la table n'a aucun élément avec la clef n, la taille de la table est gérée en internet.
> t = {1, "two",3,4} -- pas "n"
> = table.getn(t) --
calculez la taille du tableau
4
> table.setn(t, 10) -- placez la
taille à une valeur définie par utilisateur
> = table.getn(t) --
trouvent la taille
10
> table.foreach(t, copie) -- regardez le contenu
1 1
2 deux
3 3
4 4
 www.loriotpro.com |
|