Lua Academy · Lezione

map, filter, reduce

Costruisca helper di ordine superiore.

map, filter, reduce è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

I tre strumenti fondamentali

Map, filter e reduce sono gli strumenti fondamentali per elaborare liste secondo il paradigma funzionale. Ognuno riceve una lista e una funzione e restituisce un risultato, senza richiedere la scrittura manuale del ciclo.

Lua non li include nella libreria standard, ma sono brevi da scrivere e mostrano chiaramente come funzionano le funzioni di ordine superiore.

Map: trasformare ogni elemento

Map applica una funzione a ogni elemento e raccoglie i risultati in una nuova lista. La lista originale rimane invariata.

La funzione passata determina la trasformazione, quindi un solo map può gestire il raddoppio, il quadrato o qualsiasi modifica applicata ai singoli elementi.

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, ", "))

Map mantiene la lunghezza

Map restituisce sempre una lista con lo stesso numero di elementi dell'input. A ogni elemento corrisponde esattamente un elemento di output.

Se deve eliminare alcuni elementi, questo è compito di filter, non di map.

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)

Filter: conservare alcuni elementi

Filter conserva solo gli elementi per i quali un predicato restituisce true. Un predicato è una funzione che restituisce un valore booleano.

Il risultato è una nuova lista che può essere più corta di quella originale, ma mai più lunga.

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, ", "))

Filter preserva l'ordine

Filter percorre la lista in ordine e aggiunge ogni elemento mantenuto, quindi gli elementi sopravvissuti conservano la sequenza originale.

Utilizzare #out + 1 come indice mantiene il risultato come un array senza spazi vuoti, che Lua tratta come una sequenza corretta.

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, ", "))

Reduce: combinare in un unico valore

Reduce, chiamato anche fold, riduce una lista a un singolo valore. Mantiene un accumulatore e lo combina con ogni elemento usando la funzione fornita.

Fornisca un valore iniziale e una funzione di combinazione: reduce fa passare l'accumulatore attraverso ogni elemento.

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)

Reduce è flessibile

Cambiando la funzione di combinazione e il valore iniziale, reduce può sommare, moltiplicare, trovare un massimo o costruire una stringa.

Qui l'accumulatore inizia da 1 e viene moltiplicato, producendo un risultato simile a un fattoriale.

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)

Ridurre a un valore massimo

Reduce non è limitato all'aritmetica. La funzione di combinazione può confrontare i valori e conservare quello più grande a ogni passaggio.

Iniziando l'accumulatore dal primo elemento o da un numero molto piccolo, reduce può trovare il massimo in modo chiaro.

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)

Combinare i tre strumenti

La vera potenza emerge quando si combinano i tre strumenti. Filter restringe i dati, map li trasforma e reduce li riassume.

Ogni fase è un passaggio piccolo e chiaro e, insieme alle altre, sostituisce un ciclo manuale intricato.

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)

Gli originali rimangono intatti

Map e filter creano sempre nuove tabelle e non modificano mai l'input. Questo rende le pipeline prevedibili: i dati precedenti rimangono disponibili dopo ogni fase.

Anche reduce lascia invariata la lista e restituisce soltanto il risultato combinato.

Generici per qualsiasi lista

Poiché la funzione è un parametro, questi strumenti funzionano con qualsiasi tipo di dato. Lo stesso map può convertire le stringhe in maiuscolo, ridimensionare i prezzi o formattare i record.

Scrivere il ciclo una sola volta e passare funzioni diverse è esattamente il motivo per cui le funzioni di prima classe sono così utili.

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, ", "))

Verifica rapida

Rifletta su come queste operazioni modificano la lunghezza della lista.

Riepilogo

Map trasforma ogni elemento e mantiene la lunghezza, filter conserva gli elementi che soddisfano un predicato e reduce riduce una lista a un valore usando un accumulatore.

Combinare filter, map e reduce crea pipeline di dati chiare senza cicli manuali, lasciando invariate le tabelle originali.

Domande Frequenti

La lezione «map, filter, reduce» è gratuita?

Sì — il testo completo di «map, filter, reduce» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «map, filter, reduce»?

Costruisca helper di ordine superiore. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «map, filter, reduce»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Lua Academy