0Pricing
Lua Academy · Leçon

Tables utilisées comme tableaux

Créez et manipulez des tableaux indexés à partir de 1 avec table.insert et table.remove.

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

Tableaux indexés à partir de 1

Les tableaux Lua sont des tables dont les clés entières consécutives commencent à 1. Cela diffère de la plupart des langages, qui commencent à 0. Cette convention est universelle en Lua : toutes les fonctions de la bibliothèque standard supposent un indexage à partir de 1. Un accès hors limites retourne nil, et non une erreur.

local colors = {"red", "green", "blue"}
print(colors[1])   -- red
print(colors[2])   -- green
print(colors[3])   -- blue
print(colors[0])   -- nil (no index 0)
print(#colors)     -- 3 (length operator)

table.insert et table.remove

table.insert(t, val) ajoute un élément à la fin. table.insert(t, pos, val) insère un élément à une position donnée et décale les éléments vers la droite. table.remove(t, pos) supprime l'élément à la position pos (par défaut : le dernier), décale les éléments vers la gauche et retourne la valeur supprimée.

local stack = {}
table.insert(stack, "first")
table.insert(stack, "second")
table.insert(stack, "third")
print(#stack)          -- 3

table.insert(stack, 2, "inserted")
print(stack[2])        -- inserted

local removed = table.remove(stack, 1)
print(removed)         -- first
print(stack[1])        -- inserted

Pile avec des tables

Une table Lua constitue une pile parfaite. Utilisez table.insert pour empiler et table.remove pour dépiler. Par défaut, les deux opérations s'effectuent à la fin de la table, ce qui fournit un temps amorti O(1).

local stack = {}

-- Push
table.insert(stack, 10)
table.insert(stack, 20)
table.insert(stack, 30)

-- Pop
print(table.remove(stack))  -- 30
print(table.remove(stack))  -- 20
print(#stack)               -- 1

File avec des tables

Une file (FIFO) peut être implémentée avec une table, mais table.remove(t, 1) est en O(n), car il décale tous les éléments. Pour les files hautes performances, utilisez deux pointeurs (les indices de tête et de queue) afin d'éviter les décalages.

local head, tail = 1, 0
local queue = {}

local function enqueue(v)
  tail = tail + 1
  queue[tail] = v
end

local function dequeue()
  if head > tail then return nil end
  local v = queue[head]
  queue[head] = nil
  head = head + 1
  return v
end

enqueue("a"); enqueue("b"); enqueue("c")
print(dequeue())  -- a
print(dequeue())  -- b

L'opérateur de longueur #

L'opérateur # retourne la « frontière » d'une table : un indice i tel que t[i] ~= nil et t[i+1] == nil. Pour les séquences sans trous, cela correspond à la longueur du tableau. Avec des trous (nil au milieu), # produit des résultats indéfinis — utilisez table.pack ou suivez manuellement la longueur.

local t = {10, 20, 30, 40, 50}
print(#t)   -- 5

-- Safe for dense arrays
for i = #t, 1, -1 do
  io.write(t[i] .. " ")
end
print()  -- 50 40 30 20 10

Découper des tableaux

Lua ne possède pas de fonction intégrée de découpage, mais vous pouvez extraire un sous-tableau avec table.move (Lua 5.3 ou version ultérieure) ou une boucle manuelle. table.move(a1, f, e, t, a2) copie les éléments de a1[f..e] dans a2 à partir de la position t.

local src = {10,20,30,40,50,60}

-- Manual slice
local function slice(t, from, to)
  local result = {}
  for i = from, to do
    result[#result+1] = t[i]
  end
  return result
end

local sub = slice(src, 2, 4)
print(sub[1], sub[2], sub[3])  -- 20  30  40

Inverser un tableau

Inversez une table sur place en échangeant les éléments des deux extrémités vers le milieu. Il s'agit d'un algorithme classique qui fonctionne sur tout tableau Lua sans mémoire supplémentaire.

local function reverse(t)
  local n = #t
  for i = 1, math.floor(n / 2) do
    t[i], t[n - i + 1] = t[n - i + 1], t[i]
  end
end

local arr = {1, 2, 3, 4, 5}
reverse(arr)
for _, v in ipairs(arr) do
  io.write(v .. " ")
end
print()  -- 5 4 3 2 1

Concaténer des tableaux

Pour fusionner deux tableaux en un seul, parcourez le second et ajoutez ses éléments à la fin. table.move effectue cette opération efficacement avec Lua 5.3 ou version ultérieure. Le résultat est une nouvelle table contenant, dans l'ordre, tous les éléments des deux tableaux.

local function concat(a, b)
  local result = {}
  for _, v in ipairs(a) do result[#result+1] = v end
  for _, v in ipairs(b) do result[#result+1] = v end
  return result
end

local merged = concat({1,2,3}, {4,5,6})
for i, v in ipairs(merged) do
  io.write(v .. " ")
end
print()  -- 1 2 3 4 5 6

Aplatissement des tableaux imbriqués

Aplatissez récursivement un tableau imbriqué : si un élément est une table, appliquez-lui la récursion ; sinon, ajoutez-le au résultat. Il s’agit d’une application naturelle du parcours récursif des tables.

local function flatten(t, result)
  result = result or {}
  for _, v in ipairs(t) do
    if type(v) == "table" then
      flatten(v, result)
    else
      result[#result+1] = v
    end
  end
  return result
end

local nested = {1, {2, 3}, {4, {5, 6}}, 7}
local flat = flatten(nested)
print(table.concat(flat, ", "))  -- 1, 2, 3, 4, 5, 6, 7

Tableau utilisé comme ensemble

Vous pouvez implémenter un ensemble à l’aide d’une table où les valeurs sont les clés et où la valeur associée est true. La vérification de l’appartenance à l’ensemble s’effectue en O(1). Construire un ensemble à partir d’un tableau supprime les doublons. Reconvertissez-le en tableau en parcourant la table avec pairs.

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

local nums = {3,1,4,1,5,9,2,6,5,3}
local set = toSet(nums)
local unique = {}
for k in pairs(set) do unique[#unique+1] = k end
table.sort(unique)
print(table.concat(unique, " "))  -- 1 2 3 4 5 6 9

Vérification rapide

Que fait table.remove(t) lorsqu’il est appelé avec un seul argument ?

Récapitulatif : les tables comme tableaux

Résumé :

  • Les tableaux de Lua sont des tables dont l’indexation commence à 1
  • table.insert/table.remove permettent d’ajouter et de retirer des éléments à une extrémité
  • #t donne la longueur des séquences sans trous
  • Pile : insertion et suppression à la fin (O(1))
  • File : utilisez des pointeurs de début et de fin pour éviter le décalage en O(n)
  • Utilisez une table comme ensemble pour tester l’appartenance en O(1)

Questions Fréquemment Posées

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

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

Créez et manipulez des tableaux indexés à partir de 1 avec table.insert et table.remove. 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 1 sur 4.

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

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