[PDF] Cours approfondi sur les fonctions de base de Lua | Cours informatique

Fonctions mathématiques

Ce document présente les fonctions mathématiques en LUA. Ces fonctions peuvent être utilisées dans les scripts LUA de LoriotPro.

Chaque fonction est décrite, avec un exemple.  Valeur absolu (math.abs)

 Cosinus et sinus inverse (math.acos, math.asin)  Tangente Inverse (math.atan)

 Arrondi à l'entier supérieur ou inférieur (math.ceil, math.floor)  Cosinus, Sinus, Tangente (math.cos, math.sin, math.tan)  Conversion dégrés radians (math.deg, math.rad)

 Exponentiel et logarithme (math.exp, math.log)  Logarithme base 10 (math.log10)

 Exposant (math.pow)

 Valeur Min ou Max d'une liste (math.min, math.max)  Modulo, reste de division (math.mod)

 Racine carré (math.sqrt)

 Nombres pseudo-aléatoires (math.random, math.randomseed)  Normalisation (math.frexp, math.ldexp)

Valeur absolu (math.abs)

math.abs

Renvoie la valeur absolu, ou la valeur positive, d'une valeur donnée. > = math.abs(-100)

100

> = math.abs(25.67) 25.67

Cosinus et sinus inverse (math.acos, math.asin)

math.acos, math.asin

Renvoie le cosinus et le sinus inverse de la valeur donnée. > = math.acos(1) 0 > = math.acos(0) 1.5707963267949 > = math.asin(0) 0 > = math.asin(1) 1.5707963267949

Tangente Inverse (math.atan)

Renvoie la tangente inverse. Nous pouvons faire ceci en fournissant y/x en

employant math.atan ou nous pouvons passer y et x à math.atan2 pour le faire à notre place. > c, s = math.cos(0.8), math.sin(0.8) > = math.atan(s/c) 0.8 > = math.atan2(s, c) 0.8

math.atan2 doit être utilisé de préférence et en particulier quand on convertit des

coordonnées rectangulaires en coordonnées polaires. math.atan2 emploie le signe des deux arguments pour placer le résultat dans le quart de cercle correct, et produit également des valeurs correctes quand un de ses arguments est 0 ou très de près de 0. > = math.atan2(1, 0), math.atan2(-1, 0), math.atan2(0, 1), math.atan2(0, -1)

1.5707963267949 -1.5707963267949 0 3.1415926535898

Arrondi à l'entier supérieur ou inférieur (math.ceil, math.floor)

math.ceil, math.floor

Renvoie le nombre entier au-dessus et au-dessous d'une valeur donnée. > = math.floor(0.5)

0

> = math.ceil(0.5) 1

Cosinus,Sinus,Tangente (math.cos, math.sin, math.tan)

math.cos, math.sin, math.tan

Renvoie le cosinus, le sinus et la valeur de tangente pour une valeur donnée. > = math.cos(math.pi/4) 0.70710678118655 > = math.sin(0.123) 0.12269009002432 > = math.tan(5/4) 3.0095696738628 > = math.tan(.77) 0.96966832796149

Conversion dégrés radians (math.deg, math.rad)

math.deg, math.rad

Convertir des radians en degrés et vice versa. > = math.deg(math.pi) 180 > = math.deg(math.pi/2) 90 > = math.rad(180) 3.1415926535898 > = math.rad(1) 0.017453292519943

Exponentiel et logarithme (math.exp, math.log)

math.exp, math.log

math.exp() renvoie e (la base des logarithmes normaux) augmenté à une puissance

donnée.

math.log() renvoie l'inverse de ceci. e a la valeur retournée près math.exp(1).

> = math.exp(0) 1 > = math.exp(1) 2.718281828459 > = math.exp(27) 532048240601.8 > = math.log(532048240601) 26.999999999998 > = math.log(3) 1.0986122886681

Logarithme base 10 (math.log10)

math.log10

Renvoie le logarithme base 10 d'un nombre donné. Le nombre doit être positif. > = math.log10(100) 2 > = math.log10(256) 2.4082399653118 > = math.log10(-1) -1.#IND

Exposant (math.pow)

math.pow() porte le premier paramètre à la puissance du deuxième paramètre et renvoie

le résultat. L'opérateur ^ binaire exécute le même travail que math.pow(), c.-à-d.. math.pow(x, y) == x^y. > = math.pow(100,0) 1 > = math.pow(7,2) 49 > = math.pow(2,8) 256 > = math.pow(3,2.7) 19.419023519771 > = 5 ^ 2 25 > = 2^8 256

Valeur Min ou Max d'une liste (math.min, math.max)

Renvoie la valeur minimum ou maximum d'une liste de longueur variable d'arguments. > = math.min(1,2) 1 > = math.min(1.2, 7, 3) 1.2 > = math.min(1.2, -7, 3) -7 > = math.max(1.2, -7, 3) 3 > = math.max(1.2, 7, 3) 7

Modulo, reste de division (math.mod)

math.mod

Divisez le premier argument par la seconde et renvoie le reste. > = math.mod(7,3) 1 > = math.mod(9,3) 0 > = math.mod(100,2.3) 1.1

Racine carré (math.sqrt)

math.sqrt

Renvoie la racine carrée d'un nombre donné. Seulement on permet des arguments positifs. > = math.sqrt(100) 10 > = math.sqrt(1234) 35.128336140501 > = math.sqrt(-7) -1.#IND

Nombres pseudo-aléatoires (math.random, math.randomseed)

math.random, math.randomseed

math.random() produit des nombres pseudo-aléatoires uniformément distribués.

L'argument fourni change son comportement :

 math.random() sans arguments produit d'un nombre entre 0 et 1.

 math.random(upper) produit des nombres entiers entre 1 et upper.

 math.random(lower, upper) produit des nombres entiers entre lower et upper.

> = math.random() 0.0012512588885159 > = math.random() 0.56358531449324 > = math.random(100) 20 > = math.random(100) 81

> = math.random(70,80) 76

> = math.random(70,80) 75

lower et upper doivent être des nombres entiers sinon Lua convertit upper en un nombre

entier.

L'utilisation de math.floor(upper) et math.ceil(upper), donne des résultats inattendus (idem pour lower).

math.randomseed() La fonction utilise une base pour le générateur pseudo-aléatoire : Les

bases égales produisent des ordres égaux de nombres. > math.randomseed(1234)

> = math.random(), math.random(), math.random()

0.12414929654836 0.0065004425183874 0.3894466994232 > math.randomseed(1234)

> = math.random(), math.random(), math.random() 0.12414929654836 0.0065004425183874 0.3894466994232

Une bonne base est os.time(), mais il faut attendre au moins une seconde avant d'appeler la fonction pour obtenir un autre nombre aléatoire ! Pour obtenir une suit de nombres aléatoires :

math.randomseed(os.time())

Si Lua pourrait obtenir des millisecondes de os.time() l'init pourrait être meilleur fait. Néanmoins, dans certains cas nous avons besoin d'un ordre d'exécution des instructions, comme celle obtenu avec une base connue.

Mais prenez garde ! Le premier nombre aléatoire que vous obtenez 'n'est pas vraiment randomisé '(au moins dans Windows 2K et OS X). Pour obtenir à un meilleur nombre pseudo-aléatoire il faut générer quelques nombres aléatoires avant d'en obtenir un vrai : -- initialisez le pseudo générateur de nombre aléatoire

math.randomseed(os.time()) math.random() ; math.random() ; math.random() -- fait : -)

-- ce pas exactement vrai. Le premier nombre aléatoire est aussi bon (ou mauvais) que le second et les autres. La qualité du générateur dépend d'autre chose. Pour améliorer légèrement le générateur intégré nous pouvons employer une table.

Normalisation (math.frexp, math.ldexp)

math.frexp, math.ldexp

Ce sont les fonctions de normalisation . math.frexp() . La fonction est employée pour couper la valeur de nombre en fraction normale et exposant. Deux valeurs sont retournées : le premier est une valeur toujours dans la gamme 1/2 (incluse) à 1 (exclusivité) et la seconde est un exposant. math.ldexp() La fonction prend un nombre normalisé et renvoie la représentation de virgule flottante. C'est la valeur multipliée par 2 à la puissance de l'exposant. > = math.frexp(2) 0.5 2 > = math.frexp(3) 0.75 2 > = math.frexp(128) 0.5 8

> = math.frexp(3.1415927) 0.785398175 2 > = math.ldexp(0.785,2) 3.14 > = math.ldexp(0.5,8) 128

Fonctions sur les chaînes de caractères LUA

Ce document présente les fonctions de manipulation de chaînes de caractères en LUA. Ces fonctions peuvent être utilisées dans les scripts LUA de LoriotPro.

Voici la liste préliminaire de description des fonctions de Chaînes de caratères  Recherche du code ASCII d'un caractère situé dans une chaîne (string.byte)  Création d'une chaîne de caractère à partir des codes ASCII (string.char)  Enregistre un fonction dans une chaîne de caractères (string.dump)  Recherche une sous chaîne de caractère dans une chaîne (string.find)  Créer une chaîne de caratères formatées (string.format)

 Recherche d'une sous chaîne par expression régulière (string.gmatch)

 Remplacement des occurences d'une sous chaîne dans une chaîne (string.gsub)  Retourne la longueur d'un chaîne de caractères (string.len)

 Convertit les majuscules en minuscules (string.lower)  Convertit les minuscules en majuscule (string.upper)  Crée une chaîne par concaténation multiple (string.rep)  Inverse une chaîne de caractères (string.reverse)

 Sélection une sous chaînes par index début et fin (string.sub)

Note: Dans les chaînes de caractères de Lua les index (offset d'un caractère dans la

chaîne) commencent à la valeur d'index 1, et non pas la valeur d'index 0 comme en C. Consultez le chapitre Expressions régulières pour la recherche de caractères dans les chaînes de caractères

Recherche du code ASCII d'un caractère situé dans une chaîne

string.byte(s [, I ]) s:byte([i ])

Renvoie le code numérique ASCII du caractère situé à l'index I de la chaine s en argument. > = string.byte("ABCDE les") -- aucun index, ainsi index 1 du premier soit le caractère A 65

> = string.byte("ABCDE", 1) -- commencent à 1 65

> = string.byte("ABCDE", 0) -- nous n'employons pas C

> = string.byte("ABCDE", 100) -- index hors de la gamme, aucune valeur retournée

Création d'une chaîne de caractère à partir des codes ASCII

Création d'une chaîne de caractères à partir des codes ASCII passés comme arguments en i1, i2 ....

Remarque: Les codes ASCII ne sont pas nécessairement compatibles à travers les systèmes d'exploitations.

> = string.char(65,66,67) ABC

> = string.char() -- chaîne de caractères vide

Enregistre un fonction dans une chaîne de caractères

Renvoie une représentation binaire de la fonction donnée, de sorte que loadstring postérieur sur cette chaîne de caractères renvoie une copie de la fonction. La fonction doit être une fonction de Lua sans upvalues.

Recherche une sous chaîne de caractère dans une chaîne

s:find(pattern [, init [, plain ] ])

Recherche la première occurence de la sous chaîne pattern dans la chaînes de

caractères s. Si la sous chaîne est trouvé une paire de valeurs représentant le début et l'extrémité de la chaîne de caractères est retournée. Si le modèle ne peut pas être trouvé la valeur nil est retournée.

> = string.find("Hello Lua user ", "Lua") 7 9

> = string.find("Hello Lua user","banana") nil

Nous pouvons en option indiquer où commencer la recherche avec un troisième

argument init. L'argument peut également être négatif pour débuter la recherche dans la chaîne de caractères en partant de l'extrémité droite.

> = string.find("Hello Lua user ", "Lua", 1) -- commencez au premier caractère 7 9

> = string.find("Hello Lua user ", "Lua", 8) -- "Lua" non trouvé après le 8 caractère de la chaîne

nil

> = string.find("Hello Lua user ", "e", -5) -- d'abord "e" 5 caractères de l'extrémité 13 13

L'argument pattern permet également des recherches plus complexes. Voyez le Patterns Tutorial pour plus d'information. Nous pouvons arrêter le dispositif régulier d'expression en employant le quatrième argument facultatif plain. plain prend une valeur booléenne et doit être précédé de init. Par exemple,

> = string.find("Hello Lua user ", "%su") -- trouvez un caractère d'espace suivi de "u" 10 11

> = string.find("Hello Lua user ", "%su", 1, vrai) -- activer les recherches simple, maintenant pas a trouvé

nil

Créer une chaîne de caratères formatée

Créez une chaîne de caractères composée et des arguments fournis e1, e2 et respectant le format défini par formatstring. Fonction semblable à printf("format",...) en language C. Une option additionnelle %q permet la création de double guillement autour d'une chaîne de caractères.

c, d, E, e, f, g, G, I, o, u, X, et x tous s'attendent à un nombre comme argument. q et s attendent une chaîne de caractères.

> = string.format("%s %q", "Hello", "Lua User !") -- chaîne de caractères et chaîne de caractères entre double guillement

Hello "Lua user!"

> = string.format("%c%c%c", 76.117.97) -- Code caratères en ASCII Lua

> = string.format("%e, %E", math.pi, math.pi) -- exposant 3.141593e+000, 3.141593E+000

> = string.format("%f, %g", math.pi, nombre entier signé, signé, non signé de math.pi) -- virgule flottante

3.141593, 3.14159

> = string.format("%d, %i, %u", -100, -100, -100 compact) -- signé, non signé -100, -100, 4294967196

> = string.format("%o, %x, %X", -100, -100, -100) -- octal,hexa,hexa 37777777634, ffffff9c, FFFFFF9C

Type Format de la sortie

d ou i entier décimal signé

o entier octal non signé

u entier décimal non signé

x entier hexadécimal non signé

X entier hexadécimal non signé en majuscules

f réel de la forme [-]dddd.ddd

e réel de la forme [-]d.ddd e [+/-]ddd E comme e mais l'exposant est la lettre E g format e ou f suivant la précision G comme g mais l'exposant est la lettre E

c caractère

p pointeur

Recherche d'une sous chaîne par expression régulière

s:gmatch(pat)

Ceci renvoie un modèle trouvant l'iterator. L'iteration recherchera dans la chaînes de caractères passée la sous chaîne passée pat.

>for word in string.gmatch("Hello Lua user ", "%a+") do print(word) end Hello

Lua user

Remplacement des occurences d'une sous chaîne dans une

chaîne

string.gsub(s, pattern, remplace [, n ]) s:gsub(pattern, remplacent [,n ])

C'est une fonction très puissante qui peut être employée de différente manières. Utilisé simplement elle peut remplacer tous les occurence d'une sous chaîne pattern dans la chapine s. Une paire de valeurs est retournée, les chaînes de caractères modifiée et le nombre de substitutions faites. Le quatrième argument facultatif n peut être employé pour limiter le nombre de substitutions faites :

> = string.gsub("Hello banana", "banana", "LUA user") Hello Lua user 1

> = string.gsub("banana", "a", "A", 2) -- substitutions de limite faites 2 à la bAnAna 2

Si une capture est employée ceci peut être mis en référence dans les chaînes de caractères de rechange en utilisant la notation %capture_index, par exemple,

> = string.gsub("banana", "()", "%1 -") -- capturent tous les occurances "d'" et les remplacent

ban-an-a 2

> = string.gsub("banana", "a(n)", "a(%1)") -- des parenthèses autour des n qui suivent un s

ba(n)a(n)a 2

> = string.gsub("banana", "(a)(n)", "%2%1") -- renversent tous les "an"s bnanaa 2 d'an"s

Si le remplacement est une fonction et pas une chaîne de caractères, les arguments passés à la fonction sont toutes les captures qui sont faites. Si la fonction renvoie une chaîne de caractères, la valeur retournée est substituée de nouveau dans les chaînes de caractères. Juste comme string.find() nous pouvons employer des expressions régulières pour rechercher dans les chaînes de caractères . Des exemples sont présents dans le Patterns Tutorial.

> = string.gsub("Hello Lua user ", "(%w+)", print) -- imprime tous les mots trouvés Hello

Lua user

3

> = string.gsub("Hello Lua user ", "(%w+)", function(w) return string.len(w) end) -- remplacent par les longueurs des sous chaines

5 3 4 3

> = string.gsub("banana", "(a)", string.upper) -- convertie les "a" en majuscule bAnAnA 3

> = string.gsub("banana", "(a)(n)", function(a, b) return b..a end) -- inverse les lettres a et b

bnanaa 2

L'expression la plus courante pour une sélection serait (.-). Par exemple l'expression {(.-)}" sélectionne tous les caractères entre parenthèse {}. Une autre sélection fréquente est (. *) qui sélectionne tous les caractères entre parenthèse {} en incluant les parenthèses trouvés , deux exemples ici illustrent la différence.

> = string.gsub("The big {brown} fox jumped {over} the lazy {dog}.","{(.-)}", function(a) print(a) end )

brown over dog

> = string.gsub("The big {brown} fox jumped {over} the lazy {dog}.","{(.*)}", function(a) print(a) end )

brown} fox jumped {over} the lazy {dog

Retourne la longueur d'un chaîne de caractères

s:len()

Renvoyez la longueur de les chaînes de caractères passée. > = string.len("Lua")

3

> = string.len("") 0

> = string.len("Lua\000user") -- Lua strings are 8 bit pure so \000 does not terminate

8

Convertit les majuscules en minuscules

string.lower(s) s:lower()

Convertit les lettres majuscules la lettre minuscule. > = string.lower("Hello, Lua user!") hello, lua user!

Convertit les minuscules en majuscules

Convertit les lettres les minuscules en lettres majuscules. > = string.upper("Hello, Lua user!") HELLO, LUA USER!

Crée une chaîne par concaténation multiple

string.rep(s, n) s:rep(n)

Crée une chaîne par concaténation multiple de la chaîne de caractères passée en argument. > = string.rep("Lua",5) Lua Lua Lua Lua Lua > = string.rep("Lua\n", 3) Lua Lua Lua

inverse une chaîne de caractères

s:reverse(s)

Inverse une chaîne de caractères s > = string.reverse("lua")

aul

Sélectionne une sous chaîne par index début et fin

s:sub(i [,j ])

Renvoie une sous-chaîne de caractères de la chaîne passée en argument. Le début de sous-chaîne est précisé par i. Si le troisième argument j n'est pas donné, la sous-chaîne finira à l'extrémité de les chaînes de caractères. Si le troisième argument est donné, la sous-chaîne finit à et inclut j.

> = string.sub("Hello Lua user", 7) -- from character 7 until the end

Lua user

> = string.sub("Hello Lua user", 7, 9) -- from character 7 until and including 9

Lua

> = string.sub("Hello Lua user", -8) -- 8 from the end until the end

Lua user

from the start Lua

> = string.sub("Hello Lua user", -8, -6) -- 8 from the end until 6 from the end

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

 Concaténation en chaîne de caractères (table.concat)  Parcourir un table (table.foreach)

 Parcourir une table par index (table.foreachi)  Obtenir la taille d'une table (table.getn)  Trier les éléments d'une table (table.sort)  Insertion d'élément (table.insert)

 Suppression d'élément (table.remove)  Définir la taille (table.setn)

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 :

 le champ "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.

 taille implicite - autrement, la taille de l'objet est un moins le premier index de nombre entier avecune valeur 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é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

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-clef-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

> 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

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