|
Documentation language LUA |
Fonction des tableaux |
La plupart des fonctions des tableaux supposent que les tableaux représente 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 une valeur.
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 peu un étrange mais il peut être utile, par exemple, pour maintenir les listes non séquentielles.
Enchaînez les éléments d'une table ensemble
pour former une corde. Chaque élément doit pouvoir être
contraint dans une corde. On peut indiquer un séparateur qui
est placé entre les éléments enchaînés. En plus une gamme
peut être indiquée dans la table, commençant i-
élément de Th et finir au j- à l'élément de Th.
> = 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 joindre des tables ensemble parce qu'ils ne peuvent pas être contraints dans des chaînes de caractères . Voyez 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]: ?
Appliquez-vous la fonction f aux
éléments de la table passée. Sur chaque itération la
fonction f est passée la paire de clef-valeur de cet élément dans la table.
> 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 a non-nil évaluez 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 Tableaux peuvent contenir les é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 voyez table.foreachi(). Pour plus
d'informations sur ce sujet voyez la section sur les
Tableaux.
> t = { 1,2,"three"; pi=3.14159, banana="yellow" }
> table.foreach(t, print)
1 1
2 2
3 three
pi 3.14159
banana yellow
Appliquez-vous 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.
C'est semblable table.foreach() sauf que des
paires d'index-valeur ne sont passées, pas des paires de clef-valeur.
Si la fonction f renvoie a non-nil évaluez 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
La note dans l'exemple seulement les éléments classés de la table sont montrées. Voyez la section sur les tableaux pour plus d'information sur des 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 discutée au dessus de cette
page.
> = 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})
-- la note, n dépasse compter les éléments 10 > t = {1.2.3} >
table.setn(t, 10) -- a placé notre propre taille avec le setn() > =
table.getn(t) 10 > = table.getn({1,2,3,nil,5,6}) -- ordonnance des
extrémités à l'élément 3 dû à la valeur de zéro à 4 3
Assortissez les éléments d'une table sur place (c.-à-d. changez la table).
> 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
gamme indiquée est assortie, 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 adapter assortir d'élément. 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. Le
comportement de défaut est pour que < la comparaison soit
faite. Par exemple, ce qui suit se comporte les mêmes qu'aucune
fonction étant 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 pouvons voir si nous renversons la comparaison que l'ordre d'ordre est renversé.
> table.sort(t, function(a,b) return a>b end)
> = table.concat(t, ", ")
5, 4, 3, 2, 1
Insérez une valeur donnée dans une table. Si une position est donnée à insertion la valeur 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 nous apposons la valeur à 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 a inséré la
taille de la table et les index d'élément 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 utilisateur 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 à celle la 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 enlevez 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
Placez la taille d'une table (voir les notes sur
la taille de table et le dessus de cette 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 tenue intérieurement.
> 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 |
|