Lua Academy · Lektion

Sätt samman funktioner

Kedja omvandlingar.

Lektion 4 av 413 steg

Sätt samman funktioner är en gratis lektion i Lua Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lua Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lua Academy innehåller totalt 4 lektioner.

Vad är funktionssammansättning?

Funktionssammansättning kombinerar två funktioner till en. Den sammansatta funktionen skickar sitt indata genom den första funktionen och skickar sedan resultatet till den andra.

I matematik skrivs detta f(g(x)). Funktionssammansättning låter dig bygga stora transformationer av små, fokuserade funktioner.

Sätta samman två funktioner

En compose-hjälpfunktion tar två funktioner och returnerar en ny. När den anropas körs g först, och resultatet skickas sedan vidare till f.

Ordningen spelar roll: den inre funktionen körs först och den yttre funktionen körs på dess resultat.

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

Ordningen är viktig

Om du byter plats på argumenten ändras resultatet. compose(f, g) betyder att g tillämpas först och därefter f.

Exemplet nedan visar att en dubblering följd av en ökning ger ett annat svar än en ökning följd av en dubblering.

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

Sätta samman strängfunktioner

Funktionssammansättning fungerar med alla funktioner som tar ett argument, även strängtransformationer. Kedja ihop trimning, ändring av skiftläge eller vändning till ett enda återanvändbart steg.

Här körs reverse först och sedan upper, vilket ger en sträng med stora bokstäver i omvänd ordning.

local function compose(f, g) return function(x) return f(g(x)) end end

local shout = compose(string.upper, string.reverse)
print(shout("lua"))

Sätta samman många funktioner

För att kedja fler än två funktioner skriver du en variadisk composeAll. Den tillämpar funktionerna från höger till vänster, som nästlade anrop.

Loopen går bakåt genom funktionslistan och skickar värdet vidare genom varje funktion.

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

Från höger till vänster

I composeAll(a, b, c) körs funktionen längst till höger, c, först, följd av b och sedan a. Det motsvarar den nästlade formen a(b(c(x))).

Det kan vara svårt att läsa ordningen, vilket är anledningen till att vissa föredrar en pipe från vänster till höger.

En pipe från vänster till höger

En pipe vänder på läsordningen: funktionerna körs från vänster till höger, i den ordning de skrivs. Många tycker att detta är lättare att följa i datapipelines.

Loopen går framåt och tillämpar varje funktion på det löpande värdet.

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 för läsbarhet

Med pipe läses stegen uppifrån och ned i den ordning de körs. Det gör transformationer i flera steg självdokumenterande.

Här tas ett prefix bort från en sträng, den görs om till gemener och vänds sedan, där varje steg listas i den ordning det utförs.

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

Funktionssammansättning med closures

Du kan sätta samman funktioner som skapats genom partiell applicering eller closures. Bygg små specialiserade funktioner och sätt sedan ihop dem.

Det gör varje del testbar, samtidigt som sammansättningen uttrycker det övergripande flödet.

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

Funktionssammansättning och pipelines

Funktionssammansättning är det som binder samman datapipelines. I stället för att nästla anrop djupt namnger du en sammansatt funktion en gång och tillämpar den på många indata.

Det fungerar utmärkt med map: skicka en sammansatt funktion som transformationen för varje 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, ", "))

Håll funktionerna små

Funktionssammansättning belönar små funktioner med ett enda syfte. Varje funktion gör en sak, och du kombinerar dem för att skapa komplext beteende utan att skriva om logik.

Detta är kärnan i funktionell design: bygg upp ett ordförråd av små funktioner och sätt sedan samman dem för att uttrycka större idéer.

Snabb kontroll

Följ ordningen noggrant innan du svarar.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Funktionssammansättning kombinerar funktioner så att resultatet från en funktion skickas vidare till nästa. compose(f, g) kör g och sedan f, från höger till vänster, medan pipe kör från vänster till höger för bättre läsbarhet.

Med composeAll och pipe kan du kedja många små funktioner till tydliga pipelines, särskilt i kombination med map.

Gratis att börja

Lär dig Lua med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 40
Lektioner: 159

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Sätt samman funktioner” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lua Academy, inklusive ”Sätt samman funktioner”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lua Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Sätt samman funktioner”?

Kedja omvandlingar. Ni övar på Lua Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lua Academy?

Du behöver inga förkunskaper. Utbildningen i Lua Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Sätt samman funktioner”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lua Academy-lektionen?

Ja. Varje Lua Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lua Academy