Sett sammen funksjoner
Kjed sammen transformasjoner.
Sett sammen funksjoner er en gratis leksjon i Lua Academy på CoddyKit. Dette er leksjon 4 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.
Hva er funksjonssammensetning
Funksjonssammensetning kombinerer to funksjoner til én. Den sammensatte funksjonen sender inndataene gjennom den første funksjonen og gir deretter resultatet til den andre.
I matematikk skrives dette som f(g(x)). Funksjonssammensetning gjør det mulig å bygge store transformasjoner av små, fokuserte funksjoner.
Sette sammen to funksjoner
En compose-hjelpefunksjon tar to funksjoner og returnerer en ny. Når den kalles, kjøres g først, og resultatet sendes deretter inn i f.
Rekkefølgen er viktig: den indre funksjonen kjøres først, og den ytre funksjonen kjøres på resultatet.
local function compose(f, g)
return function(x)
return f(g(x))
end
end
local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end
local incThenDouble = compose(dbl, inc)
print(incThenDouble(3))Rekkefølgen er viktig
Hvis argumentene byttes om, endres resultatet. compose(f, g) betyr at g brukes først, og deretter f.
Eksempelet nedenfor viser at dobling etterfulgt av en økning gir et annet svar enn en økning etterfulgt av dobling.
local function compose(f, g) return function(x) return f(g(x)) end end
local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end
print(compose(dbl, inc)(3))
print(compose(inc, dbl)(3))Sette sammen strengfunksjoner
Funksjonssammensetning fungerer med alle funksjoner som tar ett argument, også transformasjoner av strenger. Kjed sammen trimming, endring av bokstavtype eller reversering til ett gjenbrukbart trinn.
Her kjøres reverse først, og deretter upper, slik at resultatet blir en streng med store bokstaver i omvendt rekkefølge.
local function compose(f, g) return function(x) return f(g(x)) end end
local shout = compose(string.upper, string.reverse)
print(shout("lua"))Sette sammen mange funksjoner
For å kjede sammen mer enn to funksjoner skriver man en variadisk composeAll. Den bruker funksjonene fra høyre mot venstre, på samme måte som nøstede kall.
Løkken går baklengs gjennom funksjonslisten og sender verdien videre gjennom hver funksjon.
local function composeAll(...)
local fns = {...}
return function(x)
for i = #fns, 1, -1 do
x = fns[i](x)
end
return x
end
end
local f = composeAll(function(n) return n + 1 end,
function(n) return n * 2 end,
function(n) return n - 3 end)
print(f(10))Fra høyre mot venstre
I composeAll(a, b, c) kjøres funksjonen lengst til høyre, c, først, deretter b og så a. Dette tilsvarer den nøstede formen a(b(c(x))).
Det kan være vanskelig å lese rekkefølgen, og derfor foretrekker noen en pipe fra venstre mot høyre i stedet.
En pipe fra venstre mot høyre
En pipe snur leserekkefølgen: funksjonene kjøres fra venstre mot høyre, i den rekkefølgen de er skrevet. Mange synes dette er enklere å følge i datapipelines.
Løkken går fremover og bruker hver funksjon på den løpende verdien.
local function pipe(...)
local fns = {...}
return function(x)
for i = 1, #fns do
x = fns[i](x)
end
return x
end
end
local process = pipe(function(n) return n + 1 end,
function(n) return n * 2 end)
print(process(5))Pipe for bedre lesbarhet
Med pipe leses trinnene ovenfra og ned i den rekkefølgen de utføres. Dette gjør transformasjoner med flere trinn selvforklarende.
Her trimmes en streng for et prefiks, gjøres om til små bokstaver og reverseres, med hvert trinn oppført i utførelsesrekkefølgen.
local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end
local transform = pipe(string.lower, string.reverse,
function(s) return "[" .. s .. "]" end)
print(transform("LUA"))Funksjonssammensetning med closures
Funksjoner som er laget med partiell applikasjon eller closures, kan settes sammen. Bygg små, spesialiserte funksjoner og sett dem deretter sammen.
Dette gjør hver del enkel å teste, samtidig som sammensetningen uttrykker den overordnede flyten.
local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end
local function adder(n) return function(x) return x + n end end
local function muller(n) return function(x) return x * n end end
local calc = pipe(adder(3), muller(10))
print(calc(2))Funksjonssammensetning og pipelines
Funksjonssammensetning er limet i datapipelines. I stedet for å nøste kall dypt kan man gi en sammensatt funksjon et navn én gang og bruke den på mange inndata.
Dette fungerer svært godt sammen med map: send en sammensatt funksjon inn som transformasjonen for hvert element.
local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function compose(f, g) return function(x) return f(g(x)) end end
local step = compose(function(n) return n + 1 end, function(n) return n * n end)
local r = map({1, 2, 3, 4}, step)
print(table.concat(r, ", "))Hold funksjonene små
Funksjonssammensetning belønner små funksjoner med ett formål. Hver funksjon gjør én oppgave, og de kan kombineres for å danne kompleks oppførsel uten at logikken må skrives på nytt.
Dette er kjernen i funksjonell utforming: bygg opp et vokabular av små funksjoner, og sett dem deretter sammen for å uttrykke større ideer.
Rask kontroll
Spor rekkefølgen nøye før svaret avgis.
Oppsummering
Funksjonssammensetning kombinerer funksjoner slik at resultatet fra én funksjon sendes inn i den neste. compose(f, g) kjører g og deretter f, fra høyre mot venstre, mens pipe kjører fra venstre mot høyre for bedre lesbarhet.
Med composeAll og pipe kan man kjede sammen mange små funksjoner til tydelige pipelines, noe som er spesielt kraftig sammen med map.
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
Ofte stilte spørsmål
Er leksjonen «Sett sammen funksjoner» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lua Academy, inkludert «Sett sammen funksjoner», 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 «Sett sammen funksjoner»?
Kjed sammen transformasjoner. 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 4 av 4.
Hvor lang tid tar leksjonen «Sett sammen funksjoner»?
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
- Funksjoner som verdier
- map, filter, reduce
- Partiell applikasjon
- Sett sammen funksjoner