Tables

En Python, on connaît les tableaux avec le type list et les dictionnaires avec le type dict.

# Python
tableau = [4, 78, 23, 6]
= tableau[0] # renvoie 4
 
dictio = {"A":45, "B":34}
= dictio["A"] # renvoie 45

En Lua, les 2 types sont mélangés dans un type unique, le type table.

-- Lua
tableau = {4, 18, 23, 6}
= tableau[1] -- renvoie 4
 
dictio = {A=45, B=34}
= dictio["A"] -- renvoie 45
= dictio.A -- même chose
 
melange = {23, 45, x=34, 39}
= melange[1] -- renvoie 23
= melange.x -- renvoie 34
= melange[3] -- renvoie 39
melange[9] = 6
= melange[7] -- renvoie nil

On a une syntaxe similaire au Javascript.

Important : déjà dit, l'indice de début est 1 contrairement à la plupart des langages.

Boucle for

La boucle for en Lua possède une version consistant à énumérer, comme en Python.

# Python, cas du tableau
table = ["a", "b", "c"]
for item in table:
    # item prend tout à tour les valeurs "a", "b", "c"
    # mais pas les indices 0, 1, 2
 
for indice, item in enumerate(table):
    # permet d'avoir les indices et les valeurs

En Lua on aura directement la deuxième option

-- Lua, cas du tableau
table = {"a", "b", "c"}
for indice, item in ipairs(table) do
    -- parcours avec indice et item de la table
end

Pour le cas du dictionnaire, Python passe par la production d'un tableau de clés ou un tableau de valeurs ou des deux...

# Python, cas du dictionnnaire
d = {"a":23, "b":45, "c":89}
for k in d.keys():
    # parcourt les clés "a", "b", "c"
 
for it in d.values():
    # parcourt les valeurs 23, 45, 89
 
for k, it in d.items():
    # parcourt les couples clé, valeur

En Lua, on n'a que le dernier cas :

-- Lua, cas du dictionnaire
d = {a=23, b=45, c=89}
for k, it in pairs(d) do
    -- parcours des couples clé valeur
end

On peut noter un comportement légèrement différents de pairs et ipairs. pairs parcours toutes les paires, y compris les paires avec clé numérique (comme dans un tableau donc). ipairs au contraire ne parcours que les clés numériques à partir de 1 et s'arrête dès qu'une clé numérique n'est pas définie.

-- lua, différence pairs et ipairs
d = {23, a=34, 56}
d[17] = 2
for k, it in pairs(d) do
    --parcours des paires (1,23), ("a", 34), (2, 56), (17,2)
end
 
for k, it in pairs(d) do
    -- parcours des pairs (1,23), (2,56)
    -- la clé "a" n'est pas prise en compte
    -- la clé 17 non plus car les clés de 3 à 16 sont indéfinies
end

méthodes de la classe table

d = {13, 56, 78}
= d::maxn() -- renvoie l'indice max : 3
d:insert(3,28) -- insère l'item 28 au rang 3
d:remove(1) -- enlève l'élément d'indice 1
d:sort() -- trie le tableau

Table en tant qu'objet

Une table permet de créer un objet avec méthode et attribut de la même façon qu'en Javascript.

Premier exemple.

obj = {
    x = 3,
    y = 4,
    dist2 = function(self)
      return self.x^2 + self.y^2
    end
}
 
= obj:dist2() -- renvoie 25

On a bien crée un objet doté d'attributs xet y et d'une méthode dist2.

Mais on souhaite pouvoir construire de tels objets quantité illimitée, suivant le même modèle, c'est le principe d'une classe. Il faut fournir un constructeur, c'est à dire une fonction fabriquant l'objet.

-- lua
Point = function(x, y)
    return {
        x= x, -- remarque A, voir ci-dessous
        y= y,
        dist2 = function(self)  -- remarque B
            return self.x^2 + self.y^2
        end
    }
end
 
p = Point(2, 3)
= p.x -- renvoie 2
= p:dist2() -- renvoie 13, remarque B'

Ici on comprend que la fonction Point fabrique un objet exactement comme le obj du cadre précédent.

L'équivalent en Python :

class Point:
    def __init__(self, x, y):
        self.x = x # remarque A
        self.y = y
    def dist2(self): # remarque B
        return self.x**2 + self.y**2
p = Point(2,3)
p.x # renvoie 2
p.dist2() # renvoie 13, remarque B'

remarque A : Le x apparaît à gauche et à droite du =. Celui à gauche représente l'attribut de l'objet qui est initialisé. Celui à droite représente l'argument transmis au constructeur. On leur donne le même nom car c'est plus lisible.

remarque B et B' : en B on définit la fonction avec l'argument self mais en B', la méthode est donnée sans argument. Dans les deux cas, le langage convertit automatiquement. En Lua par exemple, p:dist2() est automatiquement transformé en p.dist2(p). Le p qui appelle sa propre méthode dist2 est automatiquement placé en tant que premier argument. C'est la raison d'être de la notation : Lua.

Important : Avec cette façon de faire des objets, on se doute que la gestion des objets en Lua n'est pas aussi aboutie qu'en Java ou même qu'en Python. Il n'y pas de notion de privé / public en Lua, tout est public.