0Pricing
Lua Academy · Leçon

Parcourir des tables avec pairs et ipairs

Parcourez les tables en toute sécurité avec pairs() et ipairs().

Parcourir des tables avec pairs et ipairs est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

ipairs : parcours ordonné d’un tableau

ipairs(t) parcourt la séquence d’entiers commençant à l’index 1 et produit des paires (index, value). Il s’arrête au premier nil. C’est le choix sûr et prévisible pour les tables semblables à des tableaux lorsque l’ordre est important.

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

for i, fruit in ipairs(fruits) do
  print(i, fruit)
end
-- 1  apple
-- 2  banana
-- 3  cherry

pairs : toutes les clés

pairs(t) parcourt toutes les paires clé-valeur non nulles de la table, dans un ordre non spécifié. Il utilise la fonction next() en interne. Utilisez pairs pour les dictionnaires, les tables mixtes ou lorsque vous devez visiter toutes les clés, quel que soit leur type.

local info = {name="Lua", version=5.4, embedded=true}

for k, v in pairs(info) do
  print(k, v)
end
-- name  Lua
-- version  5.4
-- embedded  true  (order may vary)

Choisir entre pairs et ipairs

Utilisez ipairs pour les tableaux séquentiels (ordre garanti, arrêt à nil). Utilisez pairs pour les dictionnaires, les tables mixtes ou lorsque vous avez besoin de toutes les clés. Utiliser pairs sur un tableau fonctionne, mais ne garantit aucun ordre. Utiliser ipairs sur un dictionnaire ignore les clés non entières.

local mixed = {10, 20, label="hello", 30}

-- ipairs: only sees 10, 20, 30 in order
for i, v in ipairs(mixed) do
  io.write(v .. " ")
end
print()  -- 10 20 30

-- pairs: sees everything
for k, v in pairs(mixed) do
  print(k, v)
end

Compter les éléments

Pour les séquences, #t donne le nombre d’éléments. Pour les dictionnaires, #t n’est pas fiable : parcourez la table avec pairs et comptez manuellement. Cette distinction importante évite les erreurs lors de l’utilisation de tables mixtes ou dont les clés sont textuelles.

local arr = {10, 20, 30}
print("#arr:", #arr)        -- 3 (reliable)

local dict = {a=1, b=2, c=3}
print("#dict:", #dict)      -- 0 (unreliable for dicts!)

local count = 0
for _ in pairs(dict) do count = count + 1 end
print("count:", count)       -- 3

Modifier des valeurs pendant un parcours

Vous pouvez mettre à jour sans risque la valeur d’une clé existante pendant un parcours avec pairs. En revanche, ajouter ou supprimer des clés pendant le parcours produit un comportement indéfini. Rassemblez les modifications et appliquez-les après la boucle.

local prices = {apple=1.0, banana=0.5, cherry=2.0}

-- Safe: update existing values
for k, v in pairs(prices) do
  prices[k] = v * 1.1  -- 10% markup
end

for k, v in pairs(prices) do
  print(k, string.format("%.2f", v))
end

Rassembler les clés

Une opération courante consiste à rassembler toutes les clés dans un tableau trié afin d’obtenir une sortie déterministe. Parcourez la table avec pairs pour recueillir les clés, puis utilisez table.sort pour les ordonner.

local config = {host="localhost", port=8080, debug=true}
local keys = {}

for k in pairs(config) do
  keys[#keys+1] = k
end
table.sort(keys)

for _, k in ipairs(keys) do
  print(k, "=", config[k])
end
-- debug = true
-- host = localhost
-- port = 8080

Parcours de tables imbriquées

Pour des tables imbriquées (table de tables), combinez deux boucles : la boucle externe parcourt le niveau supérieur et la boucle interne parcourt chaque table imbriquée. Ce modèle prend en charge toute profondeur grâce à la récursion, pour des imbrications véritablement arbitraires.

local matrix = {
  {1,2,3},
  {4,5,6},
  {7,8,9},
}

for i, row in ipairs(matrix) do
  for j, val in ipairs(row) do
    io.write(string.format("%3d", val))
  end
  print()
end

Filtrer avec ipairs

Construisez une liste filtrée en parcourant la table avec ipairs et en ajoutant les éléments qui satisfont un prédicat. Le résultat est un nouveau tableau contenant uniquement les éléments correspondants.

local function filter(t, pred)
  local result = {}
  for _, v in ipairs(t) do
    if pred(v) then result[#result+1] = v end
  end
  return result
end

local nums = {1,2,3,4,5,6,7,8,9,10}
local evens = filter(nums, function(n) return n % 2 == 0 end)
print(table.concat(evens, " "))  -- 2 4 6 8 10

Transformer avec ipairs

Appliquez une transformation à chaque élément : parcourez le tableau et construisez-en un nouveau avec les valeurs transformées. Il s’agit de l’équivalent Lua de map() dans les langages fonctionnels.

local function map(t, fn)
  local result = {}
  for i, v in ipairs(t) do
    result[i] = fn(v)
  end
  return result
end

local nums = {1, 2, 3, 4, 5}
local doubled = map(nums, function(n) return n * 2 end)
print(table.concat(doubled, " "))  -- 2 4 6 8 10

local words = {"hello","world"}
local upper = map(words, string.upper)
print(table.concat(upper, " "))    -- HELLO WORLD

pairs avec des itérateurs personnalisés

Vous pouvez rendre un objet personnalisé itérable en renvoyant un itérateur et un état depuis une fonction. Ce modèle reflète le fonctionnement interne de pairs : il renvoie next, t, nil. Votre fabrique d’itérateurs renvoie de même une fonction et, éventuellement, un état.

local function values(t)
  local i = 0
  return function()
    i = i + 1
    return t[i]
  end
end

for v in values({"x","y","z"}) do
  print(v)
end
-- x
-- y
-- z

Vérification rapide

Quelle affirmation est vraie à propos de pairs() et ipairs() ?

Récapitulatif : pairs et ipairs

Résumé :

  • ipairs : ordre conservé, clés entières commençant à 1, arrêt à nil
  • pairs : toutes les clés, dans n’importe quel ordre, sans arrêt prématuré
  • Utilisez pairs pour les dictionnaires et ipairs pour les tableaux
  • N’ajoutez ni ne supprimez jamais de clés au cours d’un parcours avec pairs ; la mise à jour des valeurs existantes est sûre
  • Rassemblez et triez les clés pour obtenir une sortie déterministe

Questions Fréquemment Posées

La leçon « Parcourir des tables avec pairs et ipairs » est-elle gratuite ?

Oui — le texte complet de « Parcourir des tables avec pairs et ipairs » 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 « Parcourir des tables avec pairs et ipairs » ?

Parcourez les tables en toute sécurité avec pairs() et ipairs(). 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 3 sur 4.

Combien de temps prend la leçon « Parcourir des tables avec pairs et ipairs » ?

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