---
title: "Qu'est-ce qu'une table et une metatable en Lua ? - API7.ai"
description: "Table est le seul mécanisme de structuration de données en Lua. Nous pouvons utiliser les tables pour représenter des tableaux ordinaires, des tables de symboles, des ensembles, des enregistrements, des files d'attente et d'autres structures de données. Apprenez-en plus dans cet article."
url: "https://api7.ai/fr/learning-center/openresty/lua-table-and-metatable"
---

# Qu'est-ce qu'une table et une metatable en Lua ?

API7.ai

October 11, 2022

[OpenResty (NGINX + Lua)](https://api7.ai/learning-center/openresty)

Aujourd'hui, nous allons apprendre à propos de la seule structure de données dans LuaJIT : la `table`.

Contrairement à d'autres langages de script avec des structures de données riches, LuaJIT n'a qu'une seule structure de données, la `table`, qui n'est pas distinguée entre les tableaux, les tables de hachage, les collections, etc., mais qui est plutôt un mélange de tout cela. Revenons sur l'un des exemples mentionnés précédemment.

```
local color = {first = "red", "blue", third = "green", "yellow"}
print(color["first"])                 --> output: red
print(color[1])                         --> output: blue
print(color["third"])                --> output: green
print(color[2])                         --> output: yellow
print(color[3])                         --> output: nil
```

Dans cet exemple, la table `color` contient à la fois un tableau et une table de hachage, et on peut y accéder sans qu'ils interfèrent entre eux. Par exemple, vous pouvez utiliser la fonction `ipairs` pour parcourir uniquement la partie tableau de la table.

```
$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
for k, v in ipairs(color) do
      print(k)
end
'
```

Les opérations sur les `table` sont si cruciales que LuaJIT étend la bibliothèque standard `table` de Lua 5.1, et OpenResty étend encore davantage la bibliothèque `table` de LuaJIT. Examinons chacune de ces fonctions de bibliothèque.

## Les fonctions de la bibliothèque `table`

Commençons par les fonctions standard de la bibliothèque `table`. Lua 5.1 n'a pas beaucoup de fonctions dans la bibliothèque `table`, donc nous pouvons les parcourir rapidement.

### `table.getn` Obtenir le nombre d'éléments

Comme nous l'avons mentionné dans le chapitre [Standard Lua et LuaJIT](https://api7.ai/learning-center/openresty/luajit-vs-lua/), obtenir le nombre correct de tous les éléments d'une table est un gros problème dans LuaJIT.

Pour les séquences, vous pouvez utiliser `table.getn` ou l'opérateur unaire `#` pour retourner le nombre correct d'éléments. L'exemple suivant retourne le nombre 3, comme nous nous y attendions.

```
$ resty -e 'local t = { 1, 2, 3 }
  print(table.getn(t))
```

La valeur correcte ne peut pas être retournée pour les tables qui ne sont pas séquentielles. Dans le deuxième exemple, la valeur retournée est 1.

```
$ resty -e 'local t = { 1, a = 2 }
  print(#t) '
```

Heureusement, ces fonctions difficiles à comprendre ont été remplacées par des extensions de LuaJIT, que nous mentionnerons plus tard. Donc, dans le contexte d'OpenResty, n'utilisez pas la fonction `table.getn` et l'opérateur unaire `#` à moins que vous sachiez explicitement que vous obtenez la longueur d'une séquence.

De plus, `table.getn` et l'opérateur unaire `#` ne sont pas de complexité temporelle O(1) mais O(n), ce qui est une autre raison de les éviter si possible.

### `table.remove` Supprime l'élément spécifié

La deuxième fonction est `table.remove`, qui supprime des éléments dans la table en fonction des indices, c'est-à-dire que seuls les éléments de la partie tableau de la table peuvent être supprimés. Reprenons l'exemple de `color`.

```
$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
  table.remove(color, 1)
  for k, v in pairs(color) do
      print(v)
  end'
```

Ce code supprimera le `blue` avec l'indice 1. Vous pourriez demander, comment supprimer la partie table de hachage de la table ? C'est aussi simple que de définir la valeur correspondant à la clé à `nil`. Ainsi, dans l'exemple `color`, le `green` correspondant à `third` est supprimé.

```
$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
  color.third = nil
  for k, v in pairs(color) do
      print(v)
  end'
```

### `table.concat` Fonction de concaténation d'éléments

La troisième fonction est `table.concat`, qui concatène les éléments de la table en fonction des indices. Comme cela est à nouveau basé sur les indices, cela concerne toujours la partie tableau de la table. Reprenons l'exemple de `color`.

```
$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
print(table.concat(color, ", "))'
```

Après avoir utilisé la fonction `table.concat`, cela affiche `blue, yellow` et la partie table de hachage est ignorée.

De plus, cette fonction peut également spécifier la position de départ de l'indice pour effectuer la concaténation ; par exemple, elle est écrite comme suit :

```
$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow", "orange"}
print(table.concat(color, ", ", 2, 3))'
```

Cette fois, la sortie est `yellow, orange`, en sautant `blue`.

Ne sous-estimez pas cette fonction qui semble inutile, car elle peut avoir des effets inattendus lors de l'optimisation des performances et est l'un des principaux acteurs dans nos chapitres ultérieurs sur l'optimisation des performances.

### `table.insert` Insère un élément

Enfin, examinons la fonction `table.insert`. Elle insère un nouvel élément à l'indice spécifié, ce qui affecte la partie tableau de la table. Pour illustrer, reprenons l'exemple de `color`.

```
$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
table.insert(color, 1,  "orange")
print(color[1])
'
```

Vous pouvez voir que le premier élément de `color` devient `orange`, mais bien sûr, vous pouvez laisser l'indice non spécifié, de sorte qu'il sera inséré à la fin de la file par défaut.

Je dois noter que `table.insert` est une opération omniprésente, mais les performances ne sont pas bonnes. Si vous n'insérez pas d'éléments en fonction de l'indice spécifié, vous devrez appeler `lj_tab_len` de LuaJIT à chaque fois pour obtenir la longueur du tableau afin d'insérer à la fin de la file. Comme `table.getn`, la complexité temporelle pour obtenir la longueur de la table est O(n).

Donc, pour l'opération `table.insert`, nous devrions essayer de l'éviter dans le code critique. Par exemple :

```
local t = {}
for i = 1, 10000 do
     table.insert(t, i)
end
```

## Les fonctions d'extension de la table de LuaJIT

Ensuite, examinons les fonctions d'extension de la table de LuaJIT. LuaJIT étend le Lua standard avec deux fonctions de table utiles pour créer et vider une table, que je vais décrire ci-dessous.

### `table.new(narray, nhash)` Crée une nouvelle table

La première fonction est `table.new(narray, nhash)`. Au lieu de s'agrandir elle-même lors de l'insertion d'éléments, cette fonction pré-alloue la taille de l'espace pour le tableau et la table de hachage spécifiés, ce que signifient ses deux paramètres `narray` et `nhash`. L'auto-agrandissement est une opération coûteuse qui implique l'allocation d'espace, le `resize` et le `rehash`, et devrait être évitée à tout prix.

Notez ici que la documentation de `table.new` ne se trouve pas sur le site web de LuaJIT, mais est profondément enfouie dans la [documentation étendue](https://github.com/openresty/luajit2/blob/v2.1-agentzh/doc/extensions.html) du projet GitHub, donc il est difficile de la trouver même en la cherchant sur Google, donc peu d'ingénieurs la connaissent.

Voici un exemple simple, et je vais vous montrer comment cela fonctionne. Tout d'abord, cette fonction est étendue, donc avant de pouvoir l'utiliser, vous devez la `require`.

```
local new_tab = require "table.new"
local t = new_tab(100, 0)
for i = 1, 100 do
   t[i] = i
end
```

Comme vous pouvez le voir, ce code crée une nouvelle table avec 100 éléments de tableau et 0 éléments de table de hachage. Bien sûr, vous pouvez créer une nouvelle table avec 100 éléments de tableau et 50 éléments de table de hachage selon vos besoins, ce qui est légal.

```
local t = new_tab(100, 50)
```

Alternativement, si vous dépassez la taille de l'espace prédéfini, vous pouvez toujours l'utiliser normalement, mais les performances se dégraderont, et l'intérêt d'utiliser `table.new` sera perdu.

Dans l'exemple suivant, nous avons une taille prédéfinie de 100, mais nous utilisons 200.

```
local new_tab = require "table.new"
local t = new_tab(100, 0)
for i = 1, 200 do
   t[i] = i
end
```

Vous devez prédéfinir la taille de l'espace du tableau et de la table de hachage dans `table.new` en fonction du scénario réel afin de trouver un équilibre entre les performances et l'utilisation de la mémoire.

### `table.clear()` Vide la table

La deuxième fonction est la fonction de vidage `table.clear()`. Elle vide toutes les données d'une table mais ne libère pas la mémoire occupée par les parties tableau et table de hachage. Par conséquent, elle est utile lors du recyclage des tables Lua pour éviter les frais généraux de création et de destruction répétées des tables.

```
$ resty -e 'local clear_tab =require "table.clear"
local color = {first = "red", "blue", third = "green", "yellow"}
clear_tab(color)
for k, v in pairs(color) do
     print(k)
end'
```

Cependant, il n'y a pas beaucoup de scénarios où cette fonction peut être utilisée, et dans la plupart des cas, nous devrions laisser cette tâche au GC de LuaJIT.

## Les fonctions d'extension de la table d'OpenResty

Comme je l'ai mentionné au début, OpenResty maintient sa propre branche de LuaJIT, qui étend également la table, [avec plusieurs nouvelles API](https://github.com/openresty/luajit2/#new-api) : `table.isempty`, `table.isarray`, `table.nkeys` et `table.clone`.

Avant d'utiliser ces nouvelles API, veuillez vérifier la version d'OpenResty, car la plupart de ces API ne peuvent être utilisées que dans les versions d'OpenResty après 1.15.8.1. En effet, OpenResty n'a pas eu de nouvelle version pendant environ un an avant la version 1.15.8.1, et ces API ont été ajoutées pendant cet intervalle de version.

J'ai inclus un lien vers l'article, donc je vais utiliser `table.nkeys` comme exemple. Les trois autres API sont faciles à comprendre à partir de leur nom, donc parcourez la documentation GitHub, et vous comprendrez. Je dois dire que la documentation d'OpenResty est de très haute qualité, y compris les exemples de code, qu'elle peut être JIT, ce qu'il faut rechercher, etc. Plusieurs ordres de grandeur meilleurs que la documentation de Lua et LuaJIT.

D'accord, revenons à la fonction `table.nkeys`. Son nom peut vous embrouiller, mais c'est une fonction qui obtient la longueur de la table et retourne le nombre d'éléments de la table, y compris les éléments du tableau et de la partie table de hachage. Par conséquent, nous pouvons l'utiliser à la place de `table.getn`, par exemple, comme suit.

```
local nkeys = require "table.nkeys"
print(nkeys({}))  -- 0
print(nkeys({ "a", nil, "b" }))  -- 2
print(nkeys({ dog = 3, cat = 4, bird = nil }))  -- 2
print(nkeys({ "a", dog = 3, cat = 4 }))  -- 3
```

## Metatable

Après avoir parlé de la fonction `table`, examinons la `metatable` dérivée de `table`. La metatable est un concept unique en Lua, et est largement utilisée dans les projets réels. Il n'est pas exagéré de dire que vous pouvez la trouver dans presque toutes les bibliothèques `lua-resty-*`.

`Metatable` se comporte comme des surcharges d'opérateurs ; par exemple, nous pouvons surcharger `__add` pour calculer la concaténation de deux tableaux Lua ou `__tostring` pour définir des fonctions de conversion en chaînes de caractères.

Lua, d'autre part, fournit deux fonctions pour gérer les metatables.

- La première est `setmetatable(table, metatable)`, qui configure une metatable pour une table.
- La seconde est `getmetatable(table)`, qui obtient la metatable de la table.

Après tout cela, vous pourriez être plus intéressé par ce qu'elle fait, alors examinons ce que la metatable est spécifiquement utilisée pour. Voici un morceau de code d'un projet réel.

```
$ resty -e ' local version = {
  major = 1,
  minor = 1,
  patch = 1
  }
version = setmetatable(version, {
    __tostring = function(t)
      return string.format("%d.%d.%d", t.major, t.minor, t.patch)
    end
  })
  print(tostring(version))
'
```

Nous définissons d'abord une table nommée `version`, et comme vous pouvez le voir, le but de ce code est d'imprimer le numéro de version dans `version`. Cependant, nous ne pouvons pas imprimer directement `version`. Vous pouvez essayer de le faire et voir que l'impression directe ne fera que sortir l'adresse de la table.

```
print(tostring(version))
```

Donc, nous devons personnaliser la fonction de conversion en chaîne de caractères pour cette table, qui est `__tostring`, et c'est là que la metatable entre en jeu. Nous utilisons `setmetatable` pour redéfinir la méthode `__tostring` de la table `version` pour imprimer le numéro de version : 1.1.1.

En plus de `__tostring`, nous surchargeons souvent les deux métaméthodes suivantes dans la metatable dans les projets réels.

**L'une d'elles est \_\_index**. Lorsque nous recherchons un élément dans une table, nous le recherchons d'abord directement dans la table, et si nous ne le trouvons pas, nous passons à `__index` de la metatable.

Nous supprimons `patch` de la table `version` dans l'exemple suivant.

```
$ resty -e ' local version = {
  major = 1,
  minor = 1
  }
version = setmetatable(version, {
     __index = function(t, key)
         if key == "patch" then
             return 2
         end
     end,
     __tostring = function(t)
      return string.format("%d.%d.%d", t.major, t.minor, t.patch)
    end
  })
  print(tostring(version))
'
```

Dans ce cas, `t.patch` n'obtient pas la valeur, donc il passe à la fonction `__index`, qui imprime 1.1.2.

`__index` peut être non seulement une fonction mais aussi une table, et si vous essayez d'exécuter le code suivant, vous verrez qu'ils atteignent le même résultat.

```
$ resty -e ' local version = {
  major = 1,
  minor = 1
  }
version = setmetatable(version, {
     __index = {patch = 2},
     __tostring = function(t)
      return string.format("%d.%d.%d", t.major, t.minor, t.patch)
    end
  })
  print(tostring(version))
'
```

**Une autre métaméthode est \_\_call**. Elle est similaire à un foncteur qui permet d'appeler une table.

Reprenons le code ci-dessus qui imprime le numéro de version et voyons comment appeler une table.

```
$ resty -e '
local version = {
  major = 1,
  minor = 1,
  patch = 1
  }
local function print_version(t)
     print(string.format("%d.%d.%d", t.major, t.minor, t.patch))
end
version = setmetatable(version,
     {__call = print_version})
  version()
'
```

Dans ce code, nous utilisons `setmetatable` pour ajouter une metatable à la table `version`, et la métaméthode `__call` à l'intérieur pointe vers la fonction `print_version`. Donc, si nous essayons d'appeler `version` comme une fonction, la fonction `print_version` sera exécutée ici.

Et `getmetatable` est l'opération jumelée avec `setmetatable` pour obtenir la metatable qui a été configurée, comme dans le code suivant.

```
$ resty -e ' local version = {
  major = 1,
  minor = 1
  }
version = setmetatable(version, {
     __index = {patch = 2},
     __tostring = function(t)
      return string.format("%d.%d.%d", t.major, t.minor, t.patch)
    end
  })
  print(getmetatable(version).__index.patch)
'
```

En plus de ces trois métaméthodes dont nous avons parlé aujourd'hui, il y a quelques métaméthodes moins fréquemment utilisées que vous pouvez consulter dans la [documentation](http://lua-users.org/wiki/MetamethodsTutorial) pour en savoir plus lorsque vous les rencontrez.

## Programmation orientée objet

Enfin, parlons de la programmation orientée objet. Comme vous le savez peut-être, Lua n'est pas un langage orienté objet, mais nous pouvons utiliser la metatable pour implémenter la POO.

Examinons un exemple pratique. [lua-resty-mysql](https://github.com/openresty/lua-resty-mysql/blob/master/lib/resty/mysql.lua) est le client MySQL officiel d'OpenResty, et il utilise les metatables pour **simuler** les classes et les méthodes de classe, qui sont utilisées de la manière suivante.

```
    $ resty -e 'local mysql = require "resty.mysql" -- première référence à la bibliothèque lua-resty
    local db, err = mysql:new() -- Crée une nouvelle instance de la classe
    db:set_timeout(1000) -- Appelle les méthodes de la classe
```

Vous pouvez exécuter le code ci-dessus directement avec la commande `resty`. Ces lignes de code sont faciles à comprendre ; la seule chose qui pourrait vous poser problème est.

**Lors de l'appel d'une méthode de classe, pourquoi utilise-t-on un deux-points au lieu d'un point ?**

En fait, les deux-points et les points sont tous deux acceptables ici, et `db:set_timeout(1000)` et `db.set_timeout(db, 1000)` sont exactement équivalents. Le deux-points est un sucre syntaxique en Lua qui permet d'omettre le premier argument `self` d'une fonction.

Comme nous le savons tous, il n'y a pas de secrets devant le code source, alors examinons l'implémentation concrète correspondant aux lignes de code ci-dessus afin que vous puissiez mieux comprendre comment modéliser la programmation orientée objet avec les metatables.

```
local _M = { _VERSION = '0.21' } -- Utilisation de la table pour simuler une classe
local mt = { __index = _M } -- mt est l'abréviation de metatable, __index fait référence à la classe elle-même
-- Constructeur de la classe
function _M.new(self)
    local sock, err = tcp()
    if not sock then
          return nil, err
    end
    return setmetatable({ sock = sock }, mt) -- exemple de simulation de classes avec table et metatable
end

-- Fonctions membres d'une classe
function _M.set_timeout(self, timeout) -- Utilise l'argument self pour obtenir une instance de la classe sur laquelle vous souhaitez opérer
  local sock = self.sock
  if not sock then
      return nil, "not initialized"
  end

  return sock:settimeout(timeout)
end
```

La table `_M` simule une classe initialisée avec une seule variable membre `_VERSION` et définit ensuite des fonctions membres comme `_M.set_timeout`. Dans le constructeur `_M.new(self)`, nous retournons une table dont la metatable est `mt`, et la métaméthode `__index` de `mt` pointe vers `_M` afin que la table retournée simule une instance de la classe `_M`.

## Résumé

Eh bien, cela conclut le contenu principal d'aujourd'hui. La table et la metatable sont largement utilisées dans les bibliothèques `lua-resty-*` d'OpenResty et dans les projets open source basés sur OpenResty. J'espère que cette leçon vous permettra de lire et de comprendre plus facilement le code source.

Il y a d'autres fonctions standard dans Lua en plus de la table, que nous apprendrons ensemble dans la prochaine leçon.

Enfin, je voudrais vous laisser avec une question stimulante. Pourquoi la bibliothèque `lua-resty-mysql` simule-t-elle la POO avec une couche d'emballage ? N'hésitez pas à discuter de cette question dans la section des commentaires, et n'hésitez pas à partager cet article avec vos collègues et amis afin que nous puissions communiquer et progresser ensemble.

Share article link

Share

Related Posts

[![Qu'est-ce qui rend OpenResty si spécial ?](https://static.api7.ai/2022/10/14/634974e090ab4.png)](https://api7.ai/learning-center/openresty/openresty-getting-started)

## [Qu'est-ce qui rend OpenResty si spécial ?](https://api7.ai/learning-center/openresty/openresty-getting-started)

[![Que se passe-t-il en cas de conflit entre les règles Lua et la configuration NGINX ?](https://static.api7.ai/2022/10/14/634974e117ebd.png)](https://api7.ai/learning-center/openresty/conflict-between-lua-rules-and-nginx)

## [Que se passe-t-il en cas de conflit entre les règles Lua et la configuration NGINX ?](https://api7.ai/learning-center/openresty/conflict-between-lua-rules-and-nginx)

Table of Contents

- [Les fonctions de la bibliothèque `table`](#les-fonctions-de-la-biblioth%C3%A8que-table)

  - [`table.getn` Obtenir le nombre d'éléments](#tablegetn-obtenir-le-nombre-d%C3%A9l%C3%A9ments)
  - [`table.remove` Supprime l'élément spécifié](#tableremove-supprime-l%C3%A9l%C3%A9ment-sp%C3%A9cifi%C3%A9)
  - [`table.concat` Fonction de concaténation d'éléments](#tableconcat-fonction-de-concat%C3%A9nation-d%C3%A9l%C3%A9ments)
  - [`table.insert` Insère un élément](#tableinsert-ins%C3%A8re-un-%C3%A9l%C3%A9ment)

- [Les fonctions d'extension de la table de LuaJIT](#les-fonctions-dextension-de-la-table-de-luajit)

  - [`table.new(narray, nhash)` Crée une nouvelle table](#tablenewnarray-nhash-cr%C3%A9e-une-nouvelle-table)
  - [`table.clear()` Vide la table](#tableclear-vide-la-table)

- [Les fonctions d'extension de la table d'OpenResty](#les-fonctions-dextension-de-la-table-dopenresty)

- [Metatable](#metatable)

- [Programmation orientée objet](#programmation-orient%C3%A9e-objet)

- [Résumé](#r%C3%A9sum%C3%A9)
