LoriotPro Extended Edition Programmation en language LUA

Table des matières

HelpLUA

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:

 

Taille 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 :

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énation en chaîne de caractères

table.concat(table [, sept [, I [, j ] ] ])

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]: ?

Parcourir un table (table.foreach)

table.foreach(table, f)

(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

Parcourir une table par index (table.foreachi)

table.foreachi(table, f)

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

Obtenir la taille d'une table (table.getn)

table.getn(table)

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

Trier les éléments d'une table (table.sort)

table.sort(table [, élém. ])

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

Insertion d'élément (table.insert)

table.insert(table, [ position, ] valeur)

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

Suppression d'élément (table.remove)

table.remove(table [, position ])

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 (table.setn)

table.setn(table, n)

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




LUTEUS www.loriotpro.com