Lua Academy · Leçon

Tables utilisées comme dictionnaires

Utilisez des clés chaînes et mixtes pour stocker des paires clé-valeur.

Tables utilisées comme dictionnaires est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Clés textuelles

Les tables dont les clés sont des chaînes de caractères jouent le rôle de dictionnaires (tables de hachage). Accédez aux champs avec la notation par point t.key (pour les identifiants valides) ou la notation entre crochets t["key"] (pour n’importe quelle chaîne). Les deux formes sont équivalentes ; la notation entre crochets permet d’utiliser des clés dynamiques.

local user = {}
user.name = "Alice"
user["age"] = 30
user.role = "admin"

print(user.name)        -- Alice
print(user["age"])      -- 30

local field = "role"
print(user[field])      -- admin (dynamic key)

Littéraux de table

Les dictionnaires peuvent être initialisés avec un littéral de table utilisant la syntaxe key = value. C’est la manière la plus courante de créer des enregistrements en Lua. Vous pouvez mélanger des entrées de style tableau et de style dictionnaire dans un même littéral.

local config = {
  host = "localhost",
  port = 3306,
  database = "myapp",
  debug = false,
  tags = {"web", "api"},  -- nested array
}

print(config.host)        -- localhost
print(config.port)        -- 3306
print(config.tags[1])     -- web

Compter avec des dictionnaires

Un cas d’utilisation classique des dictionnaires est le comptage des fréquences. Parcourez une liste en utilisant chaque élément comme clé et en incrémentant le compteur. Vérifiez la présence de nil avant d’incrémenter : utilisez count[word] or 0 comme valeur initiale.

local words = {"lua","is","fast","lua","is","lua"}
local freq = {}

for _, w in ipairs(words) do
  freq[w] = (freq[w] or 0) + 1
end

for word, count in pairs(freq) do
  print(word, count)
end
-- lua 3, is 2, fast 1

Regrouper avec des dictionnaires

Pour regrouper des données selon une propriété, parcourez la liste et utilisez la clé de regroupement pour ajouter les éléments à une liste dans un dictionnaire. Il s’agit de l’équivalent Lua de GROUP BY en SQL ou du modèle defaultdict de Python.

local people = {
  {name="Alice", dept="eng"},
  {name="Bob",   dept="hr"},
  {name="Carol", dept="eng"},
  {name="Dave",  dept="hr"},
}
local groups = {}

for _, p in ipairs(people) do
  local d = p.dept
  groups[d] = groups[d] or {}
  groups[d][#groups[d]+1] = p.name
end

print(table.concat(groups.eng, ", "))  -- Alice, Carol

Vérifier l’existence d’une clé

Testez si une clé existe en comparant sa valeur à nil. Soyez prudent : si la valeur stockée pour une clé est nil, la clé est considérée comme absente. Pour les indicateurs de présence, stockez plutôt true comme valeur.

local cache = {result=42, mode="fast"}

if cache.result ~= nil then
  print("cached:", cache.result)  -- 42
end

-- Key not present:
if cache.timeout == nil then
  print("no timeout set")
end

-- Membership set pattern
local allowed = {admin=true, editor=true}
if allowed["admin"] then
  print("access granted")
end

Supprimer des clés

Affectez nil à une clé de table pour la supprimer. La paire clé-valeur disparaît et le ramasse-miettes peut récupérer la mémoire de la valeur. Vous ne pouvez pas supprimer une variable locale de cette manière : seules les entrées d’une table peuvent l’être.

local session = {token="abc123", user="Alice", expires=3600}
print(session.token)   -- abc123

session.token = nil
print(session.token)   -- nil (removed)

-- Count remaining keys
local count = 0
for _ in pairs(session) do count = count + 1 end
print(count)   -- 2

Fusionner des dictionnaires

Fusionnez deux tables en parcourant l’une d’elles et en copiant ses entrées dans l’autre. Si les deux tables possèdent la même clé, la valeur de la seconde table l’emporte. Il s’agit de l’équivalent Lua de Object.assign en JavaScript.

local defaults = {color="blue", size=12, bold=false}
local overrides = {color="red", italic=true}

local function merge(base, over)
  local result = {}
  for k, v in pairs(base) do result[k] = v end
  for k, v in pairs(over) do result[k] = v end
  return result
end

local opts = merge(defaults, overrides)
print(opts.color, opts.size, opts.italic)  -- red 12 true

N’importe quel type de clé

Les clés de table peuvent être n’importe quelle valeur non nulle et qui n’est pas NaN : chaînes, nombres, booléens, fonctions et même autres tables. Les clés entières et les clés textuelles sont stockées différemment en interne, mais sont accessibles uniformément avec la notation entre crochets.

local t = {}
local function myKey() end

t["string"] = 1
t[42] = 2
t[true] = 3
t[myKey] = 4

print(t["string"])  -- 1
print(t[42])        -- 2
print(t[true])      -- 3
print(t[myKey])     -- 4

Parcours ordonné

pairs() de Lua ne garantit pas l’ordre du parcours. Pour parcourir les éléments dans un ordre défini, rassemblez les clés dans un tableau, triez-le, puis parcourez-le.

local scores = {Alice=95, Bob=87, Carol=91, Dave=78}

local names = {}
for name in pairs(scores) do
  names[#names+1] = name
end
table.sort(names)

for _, name in ipairs(names) do
  print(name, scores[name])
end
-- Alice 95, Bob 87, Carol 91, Dave 78 (sorted)

Modèle des valeurs par défaut

Un modèle utile consiste à utiliser une table de « valeurs par défaut » via une métatable __index. Lorsqu’une clé n’est pas trouvée dans la table principale, Lua la recherche dans la table des valeurs par défaut. Cela permet une configuration par couches sans fusion.

local defaults = {timeout=30, retries=3, verbose=false}
local config = {timeout=60}

setmetatable(config, {__index = defaults})

print(config.timeout)  -- 60  (overridden)
print(config.retries)  -- 3   (from defaults)
print(config.verbose)  -- false (from defaults)

Vérification rapide

Comment supprimer la clé "x" de la table t en Lua ?

Récapitulatif : les tables comme dictionnaires

Points essentiels :

Notation par point et entre crochets : t.key == t["key"]
Toute valeur non nulle et qui n’est pas NaN peut être une clé
Affectez nil pour supprimer une clé
Comptage des fréquences : t[k] = (t[k] or 0) + 1
Parcours ordonné : rassemblez les clés → triez-les → parcourez-les
Utilisez une métatable __index pour les valeurs par défaut

Questions Fréquemment Posées

La leçon « Tables utilisées comme dictionnaires » est-elle gratuite ?

Oui — le texte complet de « Tables utilisées comme dictionnaires » 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 utilisées comme dictionnaires » ?

Utilisez des clés chaînes et mixtes pour stocker des paires clé-valeur. 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 2 sur 4.

Combien de temps prend la leçon « Tables utilisées comme dictionnaires » ?

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

Tables utilisées comme tableaux
Tables utilisées comme dictionnaires
Parcourir des tables avec pairs et ipairs
Tables imbriquées et données structurées

← Retour à Lua Academy