[PDF] Support de cours scripts Lua avec l'intérieur : types de variables | Cours informatique

Types des variables Lua

Cette page est une introduction aux types de variables employés par le langage de script Lua. Chaque section présente un type de variable différent.

 Nombres

 Chaînes de caractères  Tables

 Booléen  Fonctions

 Typage dynamique des variables  Valeurs à zéro

 Obtenir le type

Nombres

Lua permet l'arithmétique simple en utilisant les opérateurs habituels pour ajouter, soustraire, multiplier et diviser. Nous emploierons la fonction print() pour imprimer le résultat de calculs. Les parenthèses autour des arguments sont importantes et causeraient une erreur si elles étaient oubliées.

> print(2+2) 4 > print(2-7) -5 > print(7*8) 56 > print(7/8) 0.875

Notez que les nombres ne sont pas arrondis en nombres entiers. Ils sont en virgule flottante, ou réels. Nous pouvons assigner des valeurs aux variables en utilisant l'opérateur = .

> x = 7 > print(x) 7

La variable x est créée quand le numéro 7 lui est assigné. Nous employons la

fonction print() pour imprimer la valeur de x. Nous pouvons maintenant employer la valeur de x pour d'autres calculs.

> x = x * 9 > print(x) 63

> print(x*2) -- ne changeront pas la valeur de x 126

>print(x) 63

Remarquez la façon dont print(x*2) ne change pas la valeur x parce qu'elle n'a pas été assignée avec l'opérateur = mais avec x = x * 9, opération qui multiple la valeur courante de x par 9 et stocke la nouvelle valeur dans x.

Pour plus d'information sur lse types du nombre de Lua vous pouvez regarder le chapître Nombres.

Chaînes de caractères

Lua emploie également des chaînes de caractères ou variables de type texte : > print("hello")

hello

Nous pouvons assigner des chaînes de caractères aux variables comme nous l'avons fait avec des nombres :

> who = "Lua user" > print(who)

Lua user

Nous pouvons concaténer (assembler) des chaînes de caractères employant l'opérateur .. entre deux chaînes de caractères .

> print("hello ") hello

> print("hello " .. who) -- the variable "who" was assigned above hello Lua user

> print(who) Lua user

Notez que l'opérateur .. ne change pas la valeur de la variable who à moins que l'opérateur d'assignation = ne soit employé.

> message = "hello " .. who > print(message) hello Lua user

À la différence d' autres langages, vous ne pouvez pas employer l'opérateur + pour concaténer des chaînes de caractères c.-à-d. :

> message = "hello " + who stdin:1: attempt to perform arithmetic on a string value stack traceback:

stdin:1: in main chunk [C]: ?

Table

Lua a également un type de donnée d'usage universel appelé une table. Des Table peuvent être employés pour stocker des groupes d'objets. Vous pouvez stocker des nombres, ou des chaînes de caractères , ou d'autres tables dans les tables. Des Table sont créés en utilisant une paire de parenthèses bouclées {} .

Créons une table vide : >x = {}

>print(x)

table : 0035C910

(il est normal si votre table n'a pas la même identifiant unique comme dans l'exemple ci-dessus.)

Quand nous affichons la valeur d'une variable de table en employant la

fonction print, Lua affiche juste le fait que la variable est une table, et l'identifiant unique de cette table (c.-à-d. son adresse dans la mémoire). Nous pouvons imprimer le contenu d'une table mais cela sera expliqué dans le chapître Table.

Nous pouvons construire des tables contenant d'autres objets, tels que des nombres et des chaînes de caractères comme décrits ci-dessous dans cet exemple.

> x = { value = 123, text = "hello" } > print(x.value)

123

> print(x.text) hello

Nous pouvons imprimer les valeurs en employant la notation table.item. Nous pouvons également mettre des tables à l'intérieur d'autres tables.

Voici le cas d'une table à 2 dimensions.

> y = { const={ name="Pi", value=3.1415927 }, const2={ name="light speed", value=3e8 } } > print(y.const.name) Pi > print(y.const2.value) 300000000

Booléen

Les valeurs booléennes ont soit la valeur true soit la valeur false. Si une valeur n'est pas true, elle doit être false et vice versa.L'opérateur not peut être placé avant une valeur booléenne pour l'inverser c.-à-d.. not true est égal à false.

> x = true > print(x) true > print(not x) false > print(not false) true

Des valeurs booléennes sont employées pour représenter les résultats de tests logiques. Les operateurs de comparaison égale = =, et différent ~ = renverront des valeurs booléennes selon les valeurs qu'ils comparent.

> print(1 == 0) -- test whether two numbers are equal false

> print(1 == 1) true > print(1 ~= 0) -- test whether two numbers are not equal

true

> print(true ~= false) -- is true not equal to false? true

Fonctions

Dans Lua, des fonctions sont assignées aux variables, juste comme des nombres et des chaînes de caractères . Des fonctions sont créées en utilisantle mot-clé function. Ci-après nous créons une fonction simple qui imprimera un message d'hello. > function foo() print("hello") end -- declare the function > foo() -- call the function

hello

> print(foo) -- get the value of the variable "foo" function: 0035D6E8

Remarque: nous pouvons imprimer la valeur de la variable foo et (comme pour les tables) nous avons en retour son identifiant unique (son adresse en mémoire). Ainsi, une fonction étant une variable nous pouvons assigner des fonctions aux variables, comme pour les autres variables, ce qui donne.

> x = function() print("hello") end > x()

hello > print(x)

function: 0035EA20

La capacité à faire ceci est lié aux valeurs de premières classe. Ceci signifie que toutes les valeurs sont traitées de la même manière. C'est un dispositif très puissant et utile de Lua.

Typage dynamique des variables

Vous pourriez avoir noté que tandis que nous créions les variables ci-dessus, nous n'avons pas dû indiquer quel type de variable nous créions.

Par exemple, a = 1

b = "hello"

c = { item1="abc" }

Dans d'autres langages, telles que C, nous devons indiquer le type d'une variable quand nous la créons. De même que nous n'avons pas besoins de spécifier quel type a une variable particulière on peut également assigner différents types de valeur à la même variable, par exemple.

a = 1

a = "hello"

a = { item1="abc" }

Ceci s'appelle typage dynamique. Ceci signifie que vous ne devez pas indiquer quel type a une variable. La variable connaît son type en fonction de la valeur ou de l'objet qui lui a été assigné.

Valeurs à zéro

C'est une valeur spéciale qui signifie qu'une variable n'a aucune valeur. Si une variable a la valeur nil elle n'a aucune valeur assignée et donc elle 'existe pas encore. En plaçant une variable nil vous pouvez supprimer une variable par exemple.

> x = 2.5 > print(x) 2.5 > x = nil > print(x) nil

Vous pouvez vérifier qu'une variable existe en comparant sa valeur à nil. > print(x == nil)

true > x = 7

> print(x == nil) false

> print(x) 7

Obtenir le type

Comme LUA est un language reflectif, nous pouvons utilisé la fonction type() pour obtenir le type d'une variable particulière.

> x = "123" -- une chaîne de caractères

> print(x, type(x)) -- affiche la valeur de x et son type 123 string

> x = x + 7 -- ajoute un nombre à la chaîne et force son typage (coercition) > print(x, type(x)) -- again show the value and type

130 number

Affectation des variables

Affectation des valeurs

Changer la valeur d'une variable est une affectation. L'instruction d'affectation de valeur est ici représentée par le symbole = .

> x = 1

> y = "bonjour" > print(x, y) 1 bonjour

Affectation multiple

Dans Lua nous pouvons réaliser plusieurs affectation, par exemple: > x, y = 2, "ici et là"

> print(x, y) 2 ici et là

La liste de valeurs du côté droit est affectée la liste de variables du côté gauche du signe = .

Nous pouvons affecter autant de valeurs que nous le souhaitons et elles peuvent ne pas être toutes du même type par exemple:

> a,b,c,d,e,f = 1,"two",3,3.14159,"foo",{ this="a table" } > print(a,b,c,d,e,f)

1 two 3 3.14159 foo table: 0035BED8

Les valeurs du côté droit du signe égal peuvent être des expressions, comme i+1, mais les valeurs du côté gauche ne le peuvent pas. L'évaluation se produit avant l'affectation Toutes les expressions sont évaluées en premier par LUA. L'expression évaluée est alors affecter.

I = 7

>print(i, x) 8 7

Quand Lua atteint la deuxième ligne, il évalue les expressions i+1 et i avant toute autre chose. Après évaluation, la deuxième ligne devient i, x = 8, 7. Alors Lua effectue les affectations vers la gauche (voir ci-dessous pour l'ordre de tâche)

Permutation des valeurs

Parce que les valeurs sont affectées comme si toutes les affectations étaient simultanées, vous pouvez employer l'affectation multiple pour permuter les valeurs des variables. a,b = 1.2 -- déclare et affecte des variables

> print(a réglés, b) 1 2

> a,b = b,a -- permute les variables >print(a, b) 2 1

>a,b = b,a -- permute les variables à nouveau >print(a, b) 1 2

Ordre des affectations

L'ordre dans lequel des affectations multiples sont effectuées n'est pas défini. Ceci signifie que vous ne devriez pas supposer que les affectations sont faites de la gauches vers la droite ;

si la même variable ou référence de table se produit deux fois dans la liste des affectations, vous pouvez être étonné par les résultats.

> a, a = 1, 2 > print(a) 1

Notez, dans l'exemple ci-dessus Lua fait des affectations de droite à gauche, c.-à-d., a=2 et puis a=1.

Cependant, nous ne devrions pas dépendre de ces contraintes dans de futures versions de Lua. Si l'ordre de l'affectation est important, vous devez employer des instructions

d'affectation séparées.

En particulier, observez la déclarartion suivante. Si i==j (et i~=k), ces deux syntaxes font différentes choses :

> table[i ], table[j ] = table[j ], table[k ] > table[j ], table[i ] = table[k ], table[j ]

On devrait utiliser deux syntaxes séparés. Ceci permutent toujours les deux valeurs, cependant :

> table[i ], table[j ] = table[j ], table[i ]

Tailles mal adaptées de liste

Si une liste de valeur est plus longue que la liste de variables, les valeurs supplémentaires sont ignorées.

> a, b, c = 1.2.3.4.5.6 > print(a, b, c)

Si une liste de valeur est plus courte que la liste de variable, Lua assigne la valeur nil aux variables sans valeur.

> a, b, c, d = 1.2 > print(a, b, c, d) 1 2 nil nil

Les nombres en LUA

Représentation interne

Les languages de programmation supportent en général plusieurs types de nombres : Nombre entier, nombre entier précision illimitée, virgule flottante de précision simple, virgule flottante de double précision, nombres complexes.

Dans un intérêt de simplicité LUA supporte un seul type de nombre, le nombres à virgule flottante. Par défaut ce sont des nombres à virgule flottante de double précision, mais Lua peut facilement être recompilé pour soutenir des nombres de virgule flottante de précision simple si vous le souhaitez.

Quelques points au sujet (IEEE 754) de double virgule flottante 64-bit CONTRE les ints de 32 bits :

 Le double virgule flottante 64-bit peut représenter beaucoup plus de nombres entiers et avec précision.

 En fait, tout ce qui peut être représenter par un entier,un double peut le représenter, avec précision.

 Chaque résultat que l'arithmétique de nombre entier peut calculer correctement et avec précision, l'arithmétique avec des doubles peut le calculer correctement et avec précision.

 Puissance de dix : un double 64-bit peut représenter tous les nombres entiers avec précision, jusqu'à : 1.000.000.000.000.000 (réellement -2^53... +2^53).

 Puissance de de dix : un entier de 32 bits représente tous les nombres entiers avec précision, jusqu'à : 1.000.000.000 (réellement -2^32... +2^32-1).

Utiliser les nombres

Nous pouvons utiliser LUA en ligne de commande interactive comme calculatrice et executer des expressions.

par exemple:

Copyright de Lua 5.0 (c) 1994-2003 Tecgraf, PUC-Rio > = 1 1 > = 1 + 2 3 > = 3.1415927 3.1415927 >= 5/6 0.83333333333333

Nous pouvons écrire des nombres et évaluer des calculs simples. Lua peut également comprendre des types d'exposant pour exprimer des nombres sous la forme la < valeur > * 10 ^ < exposant > > = 1.2345e6 1234500 > = 543.21E8 54321000000 > = 2.56e-4 0.000256

Nous pouvons affecter des nombres aux variables pour faire des opérations arithmétiques : > largeur = 7.5 > taille = 12.7 > = largeur * taille 95.25 > profondeur = 2.8

> secteur = largeur * taille > volume = secteur * profondeur > print(area, volume)

95.25 266.7

Fonctions mathématiques

Lua est équipé d'une bibliothèque de maths. Les fonctions fournies sont comme suit : math.abs math.acos math.asin math.abronzage math.atan2 math.ceil math.cos math.deg math.exp math.floor math.log math.log10 math.max math.min math.mod math.pow math.rad math.sin math.sqrt math.tan math.frexp math.ldexp math.random

math.randomseed

Nous essayerons quelques unes des fonctions et des variables comme exemple. > = math.sqrt(101) 10.049875621121 > = math.pi 3.1415926535898 > = math.sin(math.pi/3) 0.86602540378444

Lisez Fonctions Mathématiques pour plus de détails.

Conversion de chaîne en nombre

Vous pouvez convertir des chaînes de caractères en nombres en utilisant la

fonction tonumber(). Ceci prend un argument chaînes de caractères et renvoie un nombre. > = tonumber("123") + 25

148

>x = tonumber("123.456e5") >print(x)

12345600

Coercition (Conversion automatique du type de variable)

Lua convertira automatiquement des types chaînes de caractères et de nombre en format correct afin d'exécuter des calculs.

Par exemple, si vous essayez d'appliquer une opération arithmétique à une chaînes de caractères, Lua essayera de convertir cette chaînes de caractères en nombre d'abord, autrement l'opération ne fonctionnera pas. Si la chaînes de caractères ne peut pas être convertie en nombre une erreur est retournée. Cette conversion automatique des types s'appelle la coercition. > = 100 + "7" 107 > = "1000" + 234 1234 > = "hello" + 234

stdin:1 : tentative d'exécuter l'arithmétique sur une chaînes de caractères traceback de la pile :

stdin:1 : dans la "chunk" principal [ C ] : ?

> = 234 + "1000" 1234

Vous pouvez constate que où une chaînes de caractères peut être convertie en nombre, le calcul réussit.

Par contre, dans l'exemple ci-dessus la chaînes de caractères "hello" ne peut pas être convertie en nombre et ainsi une erreur se produit. Dans des langues de typage

statique(par exemplele C) ceci causerait une erreur car vous ne pouvez pas assigner une valeur à une variable d'un type incompatible. Ceci fonctionne dans Lua parce qu'il est typé

dynamiquement. Nous pouvons employer la fonction de Lua type() pour obtenir une

description du type d'un objet particulier.

> x = "123" -- une chaînes de caractères (string) > print(x, type(x)) -- affiche la valeur de x et son type 123 string

> x = x + 7 -- ajoutez un nombre à la une chaînes de caractères et force la coercition > print(x, type(x)) -- affiche la valeur et le type 130 nombre

Les chaînes de caractères

 Déclaration de chaînes de caractères, guillements et crochets  Séquences d'échappement

 Guillements multilignes  Concaténation

 Fonctions sur chaîne de caractères  Coercition

Déclaration de chaînes de caractères, guillements et crochets

> = "bonjour" bonjour >= 'bonjour ' bonjour >= [ [ bonjour ] ] bonjour

Pourquoi tant de manières pour faire une chaîne de caractères ? Cela vous permet d'inclure un type de guillements dans un autre, par exemple:

> = 'hello "Lua user"' hello "Lua user"

> = "Its [[content]] hasn't got a substring." Its [[content]] hasn't got a substring. > = [[Let's have more "strings" please.]] Let's have more "strings" please.

Les chaînes de caractères encadrées par double crochets ont également quelques autres propriétés spéciales, abordées ci-dessous.

Séquences d'échappement

Lua peut également manipuler des séquences d'échappement comme en C. > = "hello \"Lua user\""

hello "Lua user"

> = 'hello\nNew line\tTab' hello

New line Tab

Les séquences d'échappement ne sont pasreconnue quand on utilise les doubles parenthèses, ainsi : > = [[hello\nNew line\tTab]] hello\nNew line\tTab Escape Sequence Represents \a Bell (alert) \b Backspace \f Formfeed \n New line \r Carriage return \t Horizontal tab \v Vertical tab

\' Single quotation mark \ " Double quotation mark

\\ Backslash

\? Literal question mark

\ ooo ASCII character in octal notation

\x hh ASCII character in hexadecimal notation

\x hhhh

Unicode character in hexadecimal notation if this escape sequence is used in a wide-character constant or a Unicode string literal.

For example, WCHAR f = L'\x4e00' or WCHAR b[] = L"The Chinese character for one is \x4e00".

Guillements multilignes

De doubles crochets peuvent être utilisés pour enfermer les chaînes de caractères littérales qui traverse plusieurs lignes par exemple,

> = [[Multiple lines of text

>> can be enclosed in double square >> brackets.]]

Multiple lines of text

can be enclosed in double square brackets.

Des lignes multiples du texte peuvent être jointes par les doubles crochets. guillements emboîtés

Les double crochets permettent de emboîtement , mais ils nécessitent que un ou plusieurs signe =soit inséré entre les crochets extérieurs pour les distinguer les ,uns des

autres. Cela ne dépend pas de combien de signe = sont insérés, tant que le nombre est le même à l'ouvertrue et à la fermeture des crochets .

> = [[one [[two [[three]] ]] ]] one [[two [[three]] ]]

Concaténation

Des chaînes de caractères peuvent être jointes en utilisant l'opérateur de concaténation "..". par exemple,

> = "hello" .. " Lua user" hello Lua user

> who = "Lua user" > = "hello "..who hello Lua user

Des nombres peuvent être enchaînés aux chaînes de caractères . Dans ce cas-ci ils sont contraints dans des chaînes de caractères et alors enchaînés. Vous pouvez lire plus au sujet de la coercition ci-dessous.

> = "Green bottles: "..10 Green bottles: 10

> = type("Green bottles: "..10) string

Fonctions sur chaîne de caractères

Lua fournit tout une gamme des fonctions pour le traitement des chaînes de caractères dans sa bibliothèque standard. Ci-dessous quelques exemples de l'utilisation de la bibliothèque de chaîne de caractères.

> = string.byte("ABCDE", 2) -- return the ASCII value of the second character 66

> = string.char(65,66,67,68,69) -- return a string constructed from ASCII values ABCDE

> = string.find("hello Lua user", "Lua") -- find substring "Lua" 7 9

> = string.find("hello Lua user", "l+") -- find one or more occurrences of "l" 3 4

3.1415927

> = string.format("%8s", "Lua") -- format a string Lua

Voir le chapitre sur les fonctions de chaines de caractères en LUA pour plus de détails.

Coercition

Lua exécute la conversion automatique des nombres en chaînes de caractères et vice versa si c'est approprié. Ceci s'appelle la coercition.

> = "This is Lua version " .. 5.0 .. " we are using." This is Lua version 5 we are using.

> = "Pi = " .. math.pi Pi = 3.1415926535898 > = "Pi = " .. 3.1415927 Pi = 3.1415927

Ci-dessus, pendant la coercition, nous n'avons pas le plein contrôle du formatage de la conversion. Pour formater le nombre comme nous le souhaitons en chaîne de caractères nous pouvons employer la fonction string.format() comme dans l' exemple ci-dessous, > = string.format("%.3f", 5.0)

5.000

> = "Lua version " .. string.format("%.1f", 5.0) Lua version 5.0

C'est une conversion explicite en utilisant une fonction pour convertir le nombre, plutôt que d'utiliser la coercition. Vous pouvez lire plus au sujet de la coercition des nombres dans Nombres.

Tables de variables

 Table en tant que rangées indexées  Table comme dictionnaires

 Constructeurs mélangés de table  Notes au sujet des index de table

Les Tables de variables sont des types de variables très flexibles et très utiles dans la programmation Lua. Cette page est une introduction à l'utilisation des Tables de variables. Lua propose une bibliothèque de fonctions de manipulation des tables pour

compléter son type de variable table.

Les exemples visibles sur cette page utilisent la bibliothèque de table standard. Reportez vous à Fonctions sur les Tables pour découvrir ces fonctions sur les Tables en détails.

Créer une table

Les Table sont créés en utilisant les constructeurs de table, qui sont définis à l'aide des parenthèses ouverte et fermée, par exemple. { } . Pour définir une table vide nous procéderons comme ci-dessous.

> t = {} -- construction d'une table vide et affectation à la variable "t" > print(t)

table: 0035AE18

Remarque: quand la valeur d'une variable table est affichée, seuls le type et son identifiant unique (ID) de l'objet sont affichés. De façon à afficher le contenu d'une table nous devons faire cela explicitement.

Table en tant que rangé avec index numérique

Des Tables peuvent être employées pour contenir des jeux de variables. Les constructeurs de Tables peuvent contenir une liste d'objets séparées par virgule pour créer une rangée. Les éléments de rangée peuvent être consultés en utilisant les crochets, le table[index ]. par exemple : > t = { 1,1,2,3,5,8,13 } > print( t[1] ) 1 > print( t[0] ) nil > print( t[4] ) 3

Notez que l'indexation dans la rangée commence à 1, pas à zéro. t[0] a la valeur nil, c.-à-d. il n'y a aucun élément à la position 0. t = { 1,1,2,3,5,8,13 } La ligne est équivalente à ce qui suit :

> t = {}

> t[1]=1 t[2]=1 t[3]=2 t[4]=3 t[5]=5 t[6]=8 t[7]=13

L'emploi des constructeurs de table est un peu plus lisible et est moins générateur d'erreur.

Nous pouvons trouver la taille d'une table en utilisant la fonction de bibliothèque de table standard table.getn() (c.-à-d. obtenez le nombre d'éléments)

> = table.getn(t) 7

Nous pouvons ajouter de nouveaux éléments dans une rangée de table en utilisant la fonction table.insert(table,value). > table.insert(t,21) > = table.getn(t) 8 > = t[7], t[8] 13 21

Nous pouvons également insérer des éléments à un endroit choisi dans la table. Nous pouvons employer la fonction table.insert pour insérer des éléments dans la rangée de table sans mimpact sur les autres éléments contigus. Pour faire ceci nous fournissons 3 arguments à la fonction table.insert(table,position,value) . Nous pouvons également employer table.remove(table,position) pour enlever des éléments d'une rangée de table.

> table.insert(t,4,99) > = t[3], t[4], t[5] 2 99 3

> table.remove(t,4) > = t[3], t[4], t[5] 2 3 5

Nous pouvons montrer les éléments contenus dans une rangée en

utilisant table.foreachi(table,function) la fonction. Ceci applique la fonction passée à chaque élément de la rangée, dans l'ordre d'index. Par exemple, si nous passons la table ci-dessus et print() la fonction nous obtenons le resultat suivant.

> table.foreachi(t,print) 1 1 2 1 3 2 4 3 5 5 6 8 7 13 8 21

Notez que nous ne sommes pas limités à stocker un type de données dans une rangée. Nous pouvons insérer des nombres, chaînes de caractères , fonctions, ou d'autres tables, par exemple.

> t[4] = "three" > t[6] = "eight"

> t[2] = { "apple", "pear", "banana" } > table.foreachi(t,print) 1 1 2 table: 0035DFE8 3 2 4 three 5 5 6 eight 7 13 8 21

Table comme dictionnaires

Des Tables peuvent également être employés pour stocker l'information qui n'est pas classée numériquement, ou séquentiellement, comme avec des rangées.

Ces types de stockage parfois s'appellent les dictionnaires, Table associatifs, liste indexé, ou associations typées. Nous emploierons le terme dictionnaire quand un élément du table a une clé et une valeur.

La clé est employée pour affecter et rechercher une valeur d'un élément de table. Nous pouvons employer le format table[key ] = valeur pour insérer des éléments dans la table. Une clé n'a pas besoin d'être un nombre, ce peut être une chaîne de caratères, ou de même n'importe quel autre objet de Lua. Construisons une table avec quelques paires de clé-valeur :

> t = { apple="green", orange="orange", banana="yellow" } > table.foreach(t,print)

apple green orange orange banana yellow

Notez que nous devons employer table.foreach(table,function) la fonction, plutôt que table.foreachi(table,function) pour produire les valeurs.

C'est parce que les index ne sont plus des nombres et table.foreachi() la fonction réitère à partir des index dans une table, tandis que table.foreach() la fonction réitère à partir des clés dans une table.

Remarque, il n'y a aucune garantie quant à l'ordre dans lequel les clés seront stockées dans une table quand on utilise des dictionnaires ainsi l'ordre de la récupération avec la fonction table.foreach()n'est pas garanti, par exemple.

> t.melon = "green" > t["strawberry"] = "red" > table.foreach(t,print) melon green strawberry red apple green orange orange banana yellow

Le format Table.key = valeur est une syntaxe possible pour l'expression table["key" ] = valeur

quand la clé est une chaîne de caractères, c.-à-d.. t.apple est peu un plus lisible que t["apple"]. Cette syntaxe rend Lua plus lisible. Dans l'exemple ci-dessus : > t = { apple="green", orange="orange", banana="yellow" }

est le même que :

> t = { ["apple"]="green", ["orange"]="orange", ["banana"]="yellow" }

Notez que si notre clé contient un espace que nous devons employer [ "format de key"]=value :

> t = { ["keys can contain more than one word"] = "as a string can contain any characters" }

> t["another string"] = 99

Constructeurs mélangés de table

Vous n'êtes pas limité à employer des constructeurs de table en tant que listes

séquentiellement indexées, ou comme dictionnaires, vous pouvez également mélanger les deux ensemble, par exemple,

> t = {2.4.6, language="Lua", version="5"}

Ici nous avons un choix de nombres suivis de quelques valeurs de dictionnaire. Nous pouvons employer nos fonctions de bibliothèque de table de Lua pour afficher le contenu de la table. > table.foreach(t,print) 1 2 2 4 3 6 language Lua version 5 > table.foreachi(t,print) 1 2 2 4 3 6

Remarquez comment les sorties diffèrent. table.foreachi() a seulement affiché le contenu numériquement indexé et table.foreach() a affiché tout le contenu. Nous pouvons utiliser les deux modèles syntaxique à volonté :

> t = {2.4.6, language="Lua", version="5", 8.10.12, web="www.lua.org"}

En raison de la coercition de nombre/chaînes, faîtes attention quand vous affichez des index. Par exemple :

t = {}; t[1] = "a"; t["1"] = "b" > for k,v in pairs(t) do print(k,v) end 1 a

1 b

Naturellement, type(k) affiche des informations différentes dans les deux cas.

Notes au sujet des index de table

Lua stocke tous les éléments dans les tables génériquement comme paires de key-valeur. Lua ne différencie pas entre les tables en rangées avec index numériques et les

dictionnaires. Toutes les tables de Lua sont réellement des dictionnaires. Dans une rangée les index sont des objets clé de type nombre.

t = { 3,6,9 } -- is the same as...

> t = { [1]=3, [2]=6, [3]=9 } -- is the same as... > t = {} t[1]=3 t[2]=6 t[3]=9

Notez que les index sont des références aux objets ainsi vous devez employer la même référence pour entrer le même index dans la table. Vous pouvez employer n'importe quel objet de Lua comme index dans une table. Nous pouvons démontrer que les index sont des références aux objets en employant une table comme index :

> a = {[ {1,2,3}]="yadda"} -- construisez une table où l'élément a une index de table > table.foreach(a, print) -- affiche le contenu de table : par de index-valeur

table : 0035BBC8 yadda

> = a[{1,2,3} ] -- affiche la valeur d'élément nil

Ceci n'a pas fonctionné parce que quand nous avons essayé de rechercher la

valeur a[{1,2,3}] nous avons construit une autre table, c.-à-d. que la table que nous avons employée comme index dans le constructeur de table n'est pas la même que celui que nous avons utilisé pour accéder à la valeur. Si nous employons la même table dans les deux cas cela fonctionnera :

> tablekey = {1,2,3} -- create a table with a variable referencing it > a = { [tablekey]="yadda" } -- construct a table using the table as a key > table.foreach(a,print) -- display the table elements

table: 0035F2F0 yadda

> = a[tablekey] -- retrieve a value from the table yadda

> print(tablekey) -- the table value is the same as the key above table: 0035F2F0

chaînes de caractères comme références

Du fait que les index sont des références, et que des chaînes de caractères peut être employé, nous allons aborder le fonctionnement interne de Lua. Nous devons nous référer à la même chaîne de caractères sinon quand nous accédons et affectons les index de table (valeur ou chaîne de caractères) cela ne fonctionneraient pas ! Des chaînes de caractères

ne sont pas reproduites dans Lua intérieurement, ainsi quand vous mettez en référence une chaîne de caractères avec la même valeur cellec-ci se rapportent à la même chaîne de caractères.

> t = { apple=5 } > a = "apple" > b = "apple"

> print(t.apple, t[a], t[b]) -- all the same value because there is only one "apple"! 5 5 5

Quelque chose comme index

Pour démontrer que nous pouvons employer tous les objets de Lua comme index : > t = { [function(x) print(x) end] = "foo" }

> for key,value in next,t do key(value) end foo

La fonction anonyme prend un argument simple, qu'elle affiche et a la valeur "foo". La lecture de la table par itération de l'index index (c.-à-d. fonction) en lui passant la valeur de la fonction, et affiche : "foo".