0Pricing
Lua Academy · Leçon

Tables imbriquées et données structurées

Construisez des structures imbriquées et accédez à des champs profondément enfouis.

Tables imbriquées et données structurées est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Principes des tables imbriquées

Les tables peuvent contenir d’autres tables comme valeurs, ce qui crée des structures d’une profondeur arbitraire. Accédez aux champs imbriqués en enchaînant les points ou les crochets. Des tables intermédiaires manquantes provoquent des erreurs : assurez-vous toujours que les tables parentes existent avant d’accéder aux champs profonds.

local company = {
  name = "CoddyKit",
  address = {
    city = "Istanbul",
    country = "Turkey",
    zip = "34000"
  },
  employees = 25
}

print(company.name)            -- CoddyKit
print(company.address.city)    -- Istanbul
print(company["address"]["zip"]) -- 34000

Accès profond sécurisé

Accéder à un champ d’une valeur nil provoque l’erreur « tentative d’indexation d’une valeur nil ». Protégez-vous contre cette erreur avec l’évaluation abrégée de and : t and t.a and t.a.b. Certaines bases de code définissent une fonction auxiliaire get(t, ...) qui parcourt en toute sécurité une chaîne de clés.

local function get(t, ...)
  local cur = t
  for _, key in ipairs({...}) do
    if type(cur) ~= "table" then return nil end
    cur = cur[key]
  end
  return cur
end

local data = {user = {profile = {age = 30}}}
print(get(data, "user", "profile", "age"))    -- 30
print(get(data, "user", "missing", "field"))  -- nil

Tableau d’enregistrements

Un modèle courant consiste à utiliser un tableau de tables (des enregistrements). Chaque élément est une table contenant des champs nommés. Parcourez-la avec ipairs et accédez aux champs par leur nom. Il s’agit de l’équivalent Lua d’un tableau d’objets ou d’une liste de structures.

local users = {
  {id=1, name="Alice", score=95},
  {id=2, name="Bob",   score=87},
  {id=3, name="Carol", score=91},
}

for _, user in ipairs(users) do
  print(user.id, user.name, user.score)
end

Construire dynamiquement des tables imbriquées

Construisez progressivement des structures imbriquées en créant les tables internes lorsque cela est nécessaire. Initialisez toujours une table avant d’y insérer des éléments. Une erreur courante consiste à oublier de créer d’abord la table interne, puis à tenter d’indexer nil.

local tree = {}
tree.root = {value = 10}
tree.root.left = {value = 5}
tree.root.right = {value = 15}
tree.root.left.left = {value = 2}

print(tree.root.value)            -- 10
print(tree.root.left.value)       -- 5
print(tree.root.left.left.value)  -- 2

Table comme configuration similaire à JSON

Les tables Lua sont souvent utilisées pour les fichiers de configuration, à la manière de JSON ou YAML. Le fichier renvoie une table, et l’application la charge avec dofile() ou require(). Les tables imbriquées représentent les sections imbriquées de la configuration.

-- config.lua (returned table)
local config = {
  server = {
    host = "0.0.0.0",
    port = 8080,
    ssl  = false,
  },
  db = {
    host = "localhost",
    name = "appdb",
    pool_size = 10,
  },
  logging = { level = "info", file = "/var/log/app.log" }
}

print(config.server.port)      -- 8080
print(config.db.pool_size)    -- 10

Graphe sous forme de liste d’adjacence

Représentez un graphe sous la forme d’une table de tables : chaque clé est un nœud et sa valeur est une liste de voisins. Cette représentation en liste d’adjacence est peu gourmande en mémoire pour les graphes creux et facile à manipuler en Lua.

local graph = {
  A = {"B", "C"},
  B = {"A", "D"},
  C = {"A", "D"},
  D = {"B", "C"},
}

-- BFS from A
local visited = {A=true}
local queue = {"A"}
while #queue > 0 do
  local node = table.remove(queue, 1)
  io.write(node .. " ")
  for _, neighbor in ipairs(graph[node]) do
    if not visited[neighbor] then
      visited[neighbor] = true
      queue[#queue+1] = neighbor
    end
  end
end
print()  -- A B C D

Modifier des champs imbriqués

Modifiez des champs imbriqués en accédant à la table parente et en affectant une valeur à la clé. Comme les tables sont transmises par référence, toute fonction qui reçoit une table peut modifier son contenu sur place : l’appelant voit les changements.

local player = {name="Hero", stats={hp=100, mp=50, atk=20}}

local function takeDamage(p, dmg)
  p.stats.hp = math.max(0, p.stats.hp - dmg)
end

takeDamage(player, 35)
print(player.stats.hp)   -- 65

player.stats.atk = player.stats.atk + 5
print(player.stats.atk)  -- 25

Sérialiser des tables imbriquées

Convertir une table imbriquée en chaîne est utile pour le débogage ou la journalisation. Un sérialiseur récursif simple gère toutes les profondeurs, mais ne prend pas en charge les cycles (références circulaires).

local function serialize(val, indent)
  indent = indent or 0
  local pad = string.rep("  ", indent)
  if type(val) ~= "table" then
    return tostring(val)
  end
  local parts = {"{"}
  for k, v in pairs(val) do
    parts[#parts+1] = pad.."  "..tostring(k).."="..serialize(v,indent+1)
  end
  parts[#parts+1] = pad.."}"
  return table.concat(parts, "\n")
end
local data = {x=1, nested={y=2, z=3}}
print(serialize(data))

Matrices creuses

Stocker naïvement une matrice à deux dimensions gaspille de la mémoire lorsque les entrées sont grandes et creuses. Ne stockez que les entrées non nulles dans une table imbriquée : matrix[row][col] = value. Cette méthode permet de représenter efficacement d’immenses matrices lorsque la plupart des valeurs sont nulles.

local function newMatrix()
  return setmetatable({}, {__index=function(t,k)
    local row = {}
    rawset(t, k, row)
    return row
  end})
end

local m = newMatrix()
m[1][1] = 5
m[3][7] = 12
m[100][200] = 99

print(m[1][1])    -- 5
print(m[3][7])    -- 12
print(m[2][5])    -- nil (sparse: no value)

Vérification de l’égalité profonde

Les tables sont comparées par référence avec ==, et non par valeur. Pour comparer structurellement des tables imbriquées, écrivez une fonction d’égalité récursive qui compare chaque paire clé-valeur et applique la récursion aux tables imbriquées.

local function deepEqual(a, b)
  if type(a) ~= type(b) then return false end
  if type(a) ~= "table" then return a == b end
  for k, v in pairs(a) do
    if not deepEqual(v, b[k]) then return false end
  end
  for k in pairs(b) do
    if a[k] == nil then return false end
  end
  return true
end
print(deepEqual({1,{2,3}},{1,{2,3}}))  -- true
print(deepEqual({1,{2,3}},{1,{2,4}}))  -- false

Vérification rapide

Que se passe-t-il lorsque vous accédez à t.a.b et que t.a vaut nil ?

Récapitulatif : tables imbriquées

Résumé :

  • Les tables peuvent être imbriquées arbitrairement : t.a.b.c
  • Protégez les accès profonds : t and t.a and t.a.b
  • Les tables sont des types référence : les fonctions les modifient sur place
  • Tableau d’enregistrements : {{name=...},{name=...}}
  • Matrice creuse : tables imbriquées pour économiser la mémoire
  • L’égalité profonde nécessite une comparaison récursive

Questions Fréquemment Posées

La leçon « Tables imbriquées et données structurées » est-elle gratuite ?

Oui — le texte complet de « Tables imbriquées et données structurées » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Tables imbriquées et données structurées » ?

Construisez des structures imbriquées et accédez à des champs profondément enfouis. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Tables imbriquées et données structurées » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Tables utilisées comme tableaux
  2. Tables utilisées comme dictionnaires
  3. Parcourir des tables avec pairs et ipairs
  4. Tables imbriquées et données structurées
← Retour à Lua Academy