Les tableaux en Lua : la structure la plus puissante sous-estimée par les débutants

Quand vous venez à Lua après Python ou JS et que vous apprenez qu'il n'y a pas de tableaux, pas d'objets, pas de dictionnaires... Il n'y a que des tables.

Votre visage : 😐

Mon visage une semaine plus tard, quand j'ai réalisé la puissance des tableaux : 🤯

Voyons pourquoi les tableaux en Lua ne sont pas une « pauvreté du langage », mais une conception ingénieuse que les débutants sous-estiment obstinément.

Attendez, il n'y a vraiment que des tableaux ?

Oui. Une structure de données pour toutes les occasions. Vous voulez un tableau ? Un tableau. Un dictionnaire ? Tableau. Objet avec des méthodes ? Vous avez deviné, c'est un tableau. Une file d'attente, une pile, un graphe, un arbre ? Ce sont tous des tableaux.

Développeur Lua expliquant l'architecture du projet :

— Et ici, nous avons un tableau de tableaux qui stocke des tableaux avec des tableaux.
— Je vois, merci.

Cela semble fou, mais en pratique, c'est incroyablement élégant.

Tableau en tant que tableau : indexation à partir de l'unité (oui, à partir de l'UNITÉ)

Voici le premier choc pour tous ceux qui viennent du monde des langues normales :

local fruits = {"apple", "banana", "cherry"}

print(fruits[1])  -- "apple"
print(fruits[0])  -- nil 😭

Indexation à partir de 1. Pas à partir de zéro. À partir de l'UNITÉ.

Chaque ancien C-shnik ressent une douleur physique à ce moment-là. Mais Lua a ses propres raisons : le langage a été conçu pour des personnes éloignées de la programmation (ingénieurs, designers), et pour eux, « le premier élément = 1 » est logique.

On s'y habitue en quelques jours. Tu souffres pendant les deux premières heures.

Classique utile : itération de tableau

local heroes = {"Lua", "Python", "JavaScript"}

for i, name in ipairs(heroes) do
    print(i .. ". " .. name)
end
-- 1. Lua
-- 2. Python
-- 3. JavaScript

ipairs — parcourt les index numériques dans l'ordre. Souvenez-vous de lui, il sera partout.

Tableau comme dictionnaire : clé-valeur sous stéroïdes

C'est là que la magie commence. Un tableau peut être à la fois un tableau et un dictionnaire :

local player = {
    name = "ProGamer228",
    level = 42,
    hp = 100,
    "hidden achievement"  -- это индекс [1]
}

print(player.name)     -- "ProGamer228"
print(player["level"]) -- 42
print(player[1])       -- "hidden achievement"

Deux formes d'accès : via un point (player.name) et via des parenthèses (player["name"]). Les crochets sont nécessaires lorsque la clé est une variable ou contient des caractères spéciaux.

local key = "hp"
print(player[key])  -- 100

-- Ключом может быть вообще что угодно
local weird = {}
weird[true] = "yes"
weird[3.14] = "pi"
weird[print] = "function as a key, why not"

La clé peut être n'importe quel type, sauf nil. Cela ouvre des possibilités folles, mais il ne faut pas en abuser, la lisibilité du code est également importante.

Longueur du tableau : tout est compliqué

L'opérateur # renvoie la longueur de la partie « massive » du tableau :

local t = {10, 20, 30, 40}
print(#t)  -- 4 ✅

local mixed = {10, 20, nil, 40}
print(# mixed)  -- peut être 2, ou peut être 4 🤡

Règle importante : s'il y a nil dans la partie massive, le comportement de # n'est pas défini. Lua peut renvoyer n'importe quel nombre. Ce n'est pas un bug, c'est par conception. Ne laissez pas de trous dans les tableaux.

Vous voulez une longueur fiable pour les dictionnaires ? Comptez manuellement :

local function tableLength(t)
    local count = 0
    for _ in pairs(t) do
        count = count + 1
    end
    return count
end

Tableau en tant qu'objet : POO à la Loach

Il n'y a pas de classes dans Lua. Mais qui cela a-t-il arrêté ?

local Dog = {}
Dog.__index = Dog

function Dog.new(name, breed)
    local self = setmetatable({}, Dog)
    self.name = name
    self.breed = breed
    return self
end

function Dog:bark()
    print(self.name .. " says: WOOF!")
end

function Dog:info()
    print(self.name .. " - breed: " .. self.breed)
end

local rex = Dog.new("Rex", "Shepherd")
rex:bark()  -- Рекс говорит: ГАВ!
rex:info()  -- Рекс — порода: Овчарка

Faites attention aux deux points (:) au lieu d'un point lors de l'appel de la méthode — c'est du sucre syntaxique qui transmet automatiquement l'objet en tant que self. Sans cela, il faudrait écrire rex.bark(rex), et cela semblerait triste.

Héritage ? Aussi à travers les tableaux

local Puppy = setmetatable({}, {__index = Dog})
Puppy.__index = Puppy

function Puppy.new(name, breed, toy)
    local self = Dog.new(name, breed)
    setmetatable(self, Puppy)
    self.toy = toy
    return self
end

function Puppy:play()
    print(self.name .. " plays with " .. self.toy .. "!")
end

local baby = Puppy.new("Bobik", "Corgi", "ball")
baby:bark()  -- Бобик говорит: ГАВ! (унаследовано от Dog)
baby:play()  -- Бобик играет с мячиком!

Les métatables et __index sont le cœur du système objet Lua. Lorsqu'un champ n'est pas trouvé dans la table actuelle, Lua regarde dans la méta-table __index. La chaîne peut être aussi longue que vous le souhaitez - voici l'héritage.

Métaméthodes : nous surchargeons tout

Les métatables permettent de redéfinir le comportement de la table pour les opérations standard :

local Vector = {}
Vector.__index = Vector

function Vector.new(x, y)
    return setmetatable({x = x, y = y}, Vector)
end

-- Перегружаем оператор сложения
function Vector.__add(a, b)
    return Vector.new(a.x + b.x, a.y + b.y)
end

-- Перегружаем вывод через tostring
function Vector.__tostring(v)
    return "(" .. v.x .. ", " .. v.y .. ")"
end

local v1 = Vector.new(1, 2)
local v2 = Vector.new(3, 4)
local v3 = v1 + v2

print(tostring(v3))  -- (4, 6)

Les principales métaméthodes à connaître :

• __add, __sub, __mul, __div — arithmétique

• __eq, __lt, __le — comparaison

• __tostring — représentation de la chaîne

• __index — accès à un champ inexistant

• __newindex — enregistrement d'un nouveau champ

• __call — appel de la table en tant que fonction

• __len - redéfinition de l'opérateur #

Avec __call vous pouvez faire un tableau appelé - et il est réellement utilisé en production :

local Logger = setmetatable({}, {
    __call = function(self, message)
        print("[LOG] " .. os.date("%H:%M:%S") .. " — " .. message)
    end
})

Logger("Server is running")  -- [LOG] 14:32:01 — Сервер запущен

Modèles pratiques : tableaux en code réel

Configuration via le tableau

local config = {
    server = {
        host = "localhost",
        port = 8080,
    },
    database = {
        name = "myapp",
        user = "admin",
        password = "hunter2",  -- классика
    },
    debug = true,
}

print(config.server.port)  -- 8080

Ensemble (Set)

local function Set(list)
    local set = {}
    for _, v in ipairs(list) do
        set[v] = true
    end
    return set
end

local langs = Set{"Lua", "Python", "JavaScript", "Lua"}

if langs["Lua"] then
    print("Lua in action!")  -- Lua в деле!
end

if not langs["COBOL"] then
    print("COBOL? No, we haven't heard of it")
end

File d'attente

local Queue = {}
Queue.__index = Queue

function Queue.new()
    return setmetatable({first = 1, last = 0}, Queue)
end

function Queue:push(value)
    self.last = self.last + 1
    self[self.last] = value
end

function Queue:pop()
    if self.first > self.last then return nil end
    local value = self[self.first]
    self[self.first] = nil
    self.first = self.first + 1
    return value
end

local q = Queue.new()
q:push("first")
q:push("second")
print(q:pop())  -- "first"
print(q:pop())  -- "second"

Principales erreurs des débutants avec les tableaux

1. Oublier que les tableaux sont transmis par lien

local a = {1, 2, 3}
local b = a       -- b указывает на ту же таблицу!
b[1] = 999
print(a[1])       -- 999 (сюрприз!)

Vous voulez une copie ? Faites-le manuellement :

local function shallowCopy(t)
    local copy = {}
    for k, v in pairs(t) do
        copy[k] = v
    end
    return copy
end

2. Confondre pairs et ipairs

• ipairs — uniquement les clés numériques, dans l'ordre, s'arrête à la première nil

• pairs — toutes les clés, l'ordre n'est pas garanti

3. Modifier le tableau pendant l'itération

Ne fais pas ça. Ne le fais pas. Rassemblez les modifications dans un tableau séparé, puis appliquez-les.

4. Considérer # comme fiable pour les tableaux avec des trous

Nous l'avons déjà dit, mais nous le répétons : nil au milieu d'un tableau = longueur imprévisible. Pas d'options.

Apprenez le Lua et d'autres langages avec Kodik !

Si vous avez lu jusqu'ici, vous êtes clairement intéressé non seulement par la théorie, mais aussi par la pratique. Les tableaux en Lua sont mieux assimilés lorsque vous écrivez du code à la main, pas seulement en lisant des articles.

Code est une application dans laquelle vous pouvez apprendre la programmation à partir de zéro et améliorer vos compétences grâce à des exercices pratiques. Python, JavaScript, HTML, CSS et d'autres technologies, le tout en mettant l'accent sur le fait que vous écrivez réellement du code, et pas seulement que vous le regardez.

Et nous avons aussi Chaîne Telegram avec une communauté de plus de 2000 développeurs, où des messages utiles, des analyses de tâches et des mèmes sur la programmation sont régulièrement publiés (sans eux, nulle part). Une excellente façon de réviser le matériel dans un endroit pratique : dans la file d'attente, dans les transports, au déjeuner. Abonnez-vous et améliorez-vous chaque jour.

En résumé : pourquoi les tableaux sont-ils géniaux ?

Les tables en Lua sont un couteau suisse qui semble étrange au début, puis vous ne comprenez pas comment vous avez vécu sans lui. Une structure de données au lieu de dix, un minimum de syntaxe, un maximum de flexibilité.

Voici ce qu'il faut retenir :

• Les tableaux remplacent les tableaux, les dictionnaires, les objets, les classes et tout le reste

• L'indexation à partir de 1 n'est pas un bug, mais une fonctionnalité (acceptez-le simplement)

• Les métatables transforment les tables en un système d'objets à part entière

• Les tableaux sont transmis par lien — soyez prudent avec la copie

• # fonctionne de manière fiable uniquement pour les tableaux sans trous

Lua est un langage qui prouve que moins, c'est plus. Et les tableaux sont le meilleur exemple de cette philosophie.

Maintenant, allez écrire quelque chose en Lua. Les tableaux attendent. 🚀