<markdown>
# Tables

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

```python
# 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
-- 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
# 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
-- 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
# 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
-- 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
-- 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

```lua
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.

```lua
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 `x`et `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
-- 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 :

```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.
</markdown>