Lua Academy · leksjon

map, filter, reduce

Bygg hjelpefunksjoner av høyere orden.

Leksjon 2 av 413 trinn

map, filter, reduce er en gratis leksjon i Lua Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Lua Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Lua Academy inneholder totalt 4 leksjoner.

De tre store

Map, filter og reduce er kjerneverktøyene for funksjonell listebehandling. Hvert av dem tar en liste og en funksjon, og returnerer et resultat uten at du må skrive løkken selv.

Lua leveres ikke med disse innebygd, men de er korte å skrive og viser hvordan høyereordensfunksjoner fungerer.

Map: transformer hvert element

Map bruker en funksjon på hvert element og samler resultatene i en ny liste. Den opprinnelige listen forblir uendret.

Funksjonen du sender inn, bestemmer transformasjonen, så én map-funksjon håndterer dobling, kvadrering eller enhver endring per element.

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 bevarer lengden

Map returnerer alltid en liste med like mange elementer som inndataene. Hvert element blir til nøyaktig ett resultatelement.

Hvis du trenger å fjerne elementer, er det filter sin oppgave, ikke map sin.

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: behold noen elementer

Filter beholder bare elementene som et predikat returnerer true for. Et predikat er en funksjon som returnerer en boolsk verdi.

Resultatet er en ny liste som kan være kortere enn den opprinnelige, men aldri lengre.

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 bevarer rekkefølgen

Filter går gjennom listen i rekkefølge og legger til hvert element som beholdes, slik at de gjenværende elementene beholder den opprinnelige rekkefølgen.

Ved å bruke #out + 1 som indeks får du en array uten hull, som Lua behandler som en ordentlig sekvens.

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: slå sammen til én verdi

Reduce (også kalt fold) samler en liste til én enkelt verdi. Den fører en akkumulator videre og kombinerer den med hvert element ved hjelp av funksjonen din.

Du oppgir en startverdi og en kombineringsfunksjon, og reduce fører akkumulatoren gjennom hvert element.

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 er fleksibel

Ved å endre kombineringsfunksjonen og startverdien kan reduce summere, multiplisere, finne en maksimumsverdi eller bygge en streng.

Her starter akkumulatoren på 1 og multipliseres, slik at resultatet blir et produkt av faktorialtypen.

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)

Finn maksimum med reduce

Reduce er ikke begrenset til aritmetikk. Kombineringsfunksjonen kan sammenligne verdier og beholde den største for hvert trinn.

Hvis du starter akkumulatoren med det første elementet eller med et svært lite tall, kan reduce finne maksimum på en ryddig måte.

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)

Kjed dem sammen

Den virkelige styrken blir synlig når du kjeder de tre sammen. Filter begrenser dataene, map transformerer dem, og reduce oppsummerer dem.

Hvert trinn er et lite og tydelig steg, og til sammen erstatter de en innviklet manuell løkke.

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)

Originalene forblir uendret

Map og filter bygger alltid nye tabeller og endrer aldri inndataene. Dermed blir datapipeliner forutsigbare: tidligere data er fortsatt tilgjengelige etter hvert trinn.

Reduce lar også listen være urørt og returnerer bare det kombinerte resultatet.

Fungerer med alle lister

Fordi funksjonen er en parameter, fungerer disse verktøyene med alle typer data. Den samme map-funksjonen kan gjøre strenger om til store bokstaver, skalere priser eller formatere poster.

Å skrive løkken én gang og sende inn forskjellige funksjoner er nettopp grunnen til at førsteklasses funksjoner er så nyttige.

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

Rask sjekk

Tenk over hvordan disse operasjonene påvirker listelengden.

Besvar den i den interaktive leksjonen

Oppsummering

Map transformerer hvert element og bevarer lengden, filter beholder elementer som oppfyller et predikat, og reduce samler en liste til én verdi ved hjelp av en akkumulator.

Ved å kjede sammen filter, map og reduce bygger du tydelige datapipeliner uten manuelle løkker, og de opprinnelige tabellene forblir uendret.

Gratis å komme i gang

Lær deg Lua med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 40
Leksjoner: 159

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «map, filter, reduce» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lua Academy, inkludert «map, filter, reduce», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Lua Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «map, filter, reduce»?

Bygg hjelpefunksjoner av høyere orden. Du øver på Lua Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Lua Academy?

Ingen tidligere erfaring er nødvendig. Lua Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «map, filter, reduce»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Lua Academy-leksjonen?

Ja. Alle Lua Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Lua Academy