Lua Academy · Leçon

map, filter, reduce

Construisez des assistants d’ordre supérieur.

map, filter, reduce 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.

Les trois opérations fondamentales

La transformation, le filtrage et la réduction sont les outils essentiels du traitement fonctionnel des listes. Chacune prend une liste et une fonction, puis renvoie un résultat sans que vous ayez à écrire la boucle vous-même.

Lua ne les intègre pas par défaut, mais elles sont rapides à écrire et montrent clairement le fonctionnement des fonctions d'ordre supérieur.

Transformer chaque élément

La transformation applique une fonction à chaque élément et rassemble les résultats dans une nouvelle liste. La liste d'origine reste inchangée.

La fonction que vous transmettez définit la transformation ; une seule fonction map peut donc doubler, mettre au carré ou modifier chaque élément de n'importe quelle autre manière.

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

local r = map({1, 2, 3}, function(x) return x * x end)
print(table.concat(r, ", "))

La transformation conserve la longueur

Une transformation renvoie toujours une liste contenant le même nombre d'éléments que l'entrée. Chaque élément produit exactement un élément de sortie.

Si vous devez supprimer des éléments, c'est le rôle du filtrage, pas de la transformation.

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

local names = {"ada", "lin", "sam"}
local caps = map(names, string.upper)
print(table.concat(caps, " "))
print(#caps)

Filtrer : conserver certains éléments

Le filtrage ne conserve que les éléments pour lesquels un prédicat renvoie vrai. Un prédicat est une fonction qui renvoie une valeur booléenne.

Le résultat est une nouvelle liste qui peut être plus courte que l'originale, mais jamais plus longue.

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

local evens = filter({1,2,3,4,5,6}, function(x) return x % 2 == 0 end)
print(table.concat(evens, ", "))

Le filtrage conserve l'ordre

Le filtrage parcourt la liste dans l'ordre et ajoute chaque élément conservé ; les éléments restants gardent donc leur séquence d'origine.

Utiliser #out + 1 comme indice conserve un tableau sans trous, que Lua considère comme une séquence correcte.

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

local long = filter({"hi", "hello", "yo", "howdy"},
  function(s) return #s > 2 end)
print(table.concat(long, ", "))

Réduire : combiner en une seule valeur

La réduction, aussi appelée agrégation, condense une liste en une seule valeur. Elle conserve un accumulateur et le combine avec chaque élément à l'aide de votre fonction.

Vous fournissez une valeur initiale et une fonction de combinaison, puis la réduction fait passer l'accumulateur à travers chaque élément.

local function reduce(t, f, acc)
  for _, v in ipairs(t) do
    acc = f(acc, v)
  end
  return acc
end

local sum = reduce({1,2,3,4}, function(a, x) return a + x end, 0)
print(sum)

La réduction est flexible

En modifiant la fonction de combinaison et la valeur initiale, la réduction peut additionner, multiplier, rechercher un maximum ou construire une chaîne de caractères.

Ici, l'accumulateur commence à 1 et effectue des multiplications, ce qui produit un résultat de type factorielle.

local function reduce(t, f, acc)
  for _, v in ipairs(t) do acc = f(acc, v) end
  return acc
end

local product = reduce({1,2,3,4,5}, function(a, x) return a * x end, 1)
print(product)

Réduire jusqu'à un maximum

La réduction ne se limite pas aux calculs arithmétiques. La fonction de combinaison peut comparer les valeurs et conserver la plus grande à chaque étape.

Commencer l'accumulateur au premier élément ou à un nombre très petit permet à la réduction de trouver simplement un maximum.

local function reduce(t, f, acc)
  for _, v in ipairs(t) do acc = f(acc, v) end
  return acc
end

local max = reduce({3, 8, 2, 11, 6},
  function(a, x) if x > a then return x else return a end end, -math.huge)
print(max)

Les enchaîner

Le véritable intérêt apparaît lorsque vous enchaînez les trois opérations. Le filtrage restreint les données, la transformation les modifie et la réduction les résume.

Chaque étape est petite et claire ; ensemble, elles remplacent une boucle manuelle difficile à suivre.

local function filter(t, p) local o={} for _,v in ipairs(t) do if p(v) then o[#o+1]=v end end return o end
local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function reduce(t, f, a) for _,v in ipairs(t) do a=f(a,v) end return a end

local nums = {1,2,3,4,5,6}
local r = reduce(map(filter(nums, function(x) return x%2==0 end),
  function(x) return x*x end), function(a,x) return a+x end, 0)
print(r)

Les originaux restent intacts

La transformation et le filtrage construisent toujours de nouvelles tables et ne modifient jamais l'entrée. Les chaînes de traitement deviennent ainsi prévisibles : les données précédentes restent disponibles après chaque étape.

La réduction laisse elle aussi la liste intacte et ne renvoie que le résultat combiné.

Applicable à toute liste

Comme la fonction est un paramètre, ces outils fonctionnent avec toutes sortes de données. La même fonction map met des chaînes en majuscules, ajuste des prix ou met des enregistrements en forme.

Écrire la boucle une seule fois et transmettre différentes fonctions est précisément ce qui rend les fonctions de première classe si utiles.

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

local prices = {10, 20, 30}
local withTax = map(prices, function(p) return p * 1.18 end)
print(table.concat(withTax, ", "))

Vérification rapide

Réfléchissez à l'effet de ces opérations sur la longueur d'une liste.

Récapitulatif

La transformation modifie chaque élément tout en conservant la longueur, le filtrage conserve les éléments qui satisfont un prédicat et la réduction condense une liste en une seule valeur à l'aide d'un accumulateur.

Enchaîner le filtrage, la transformation et la réduction permet de créer des chaînes de traitement claires sans boucles manuelles, tout en laissant les tables d'origine inchangées.

Questions Fréquemment Posées

La leçon « map, filter, reduce » est-elle gratuite ?

Oui — le texte complet de « map, filter, reduce » 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 « map, filter, reduce » ?

Construisez des assistants d’ordre supérieur. 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 « map, filter, reduce » ?

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

← Retour à Lua Academy