Komponowanie funkcji
Połączy Pan/Pani przekształcenia w łańcuch.
Komponowanie funkcji to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Lua Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Lua Academy zawiera 4 lekcji w sumie.
Czym jest kompozycja
Kompozycja funkcji łączy dwie funkcje w jedną. Funkcja złożona przekazuje swoje dane wejściowe przez pierwszą funkcję, a następnie przekazuje otrzymany wynik do drugiej.
W matematyce zapisuje się to jako f(g(x)). Kompozycja pozwala budować duże przekształcenia z małych, wyspecjalizowanych funkcji.
Kompozycja dwóch funkcji
Funkcja pomocnicza compose przyjmuje dwie funkcje i zwraca nową. Jej wywołanie uruchamia najpierw g, a następnie przekazuje wynik do f.
Kolejność ma znaczenie: najpierw uruchamiana jest funkcja wewnętrzna, a funkcja zewnętrzna działa na jej wyniku.
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))Kolejność ma znaczenie
Zamiana argumentów zmienia wynik. compose(f, g) oznacza zastosowanie najpierw funkcji g, a następnie f.
Poniższy przykład pokazuje, że podwojenie, a następnie zwiększenie o jeden daje inny wynik niż zwiększenie o jeden, a następnie podwojenie.
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))Kompozycja funkcji operujących na ciągach znaków
Kompozycja działa z dowolnymi funkcjami jednoargumentowymi, w tym z funkcjami przekształcającymi ciągi znaków. Przycinanie, zmianę wielkości liter lub odwracanie można połączyć w jeden wielokrotnego użytku krok.
W tym przypadku funkcja reverse jest uruchamiana jako pierwsza, a następnie upper, co daje ciąg znaków zapisany od tyłu wielkimi literami.
local function compose(f, g) return function(x) return f(g(x)) end end
local shout = compose(string.upper, string.reverse)
print(shout("lua"))Kompozycja wielu funkcji
Aby połączyć więcej niż dwie funkcje, należy napisać wariadyczną funkcję composeAll. Stosuje ona funkcje od prawej do lewej, podobnie jak wywołania zagnieżdżone.
Pętla przechodzi wstecz przez listę funkcji, przekazując wartość przez każdą z nich.
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))Od prawej do lewej
W wyrażeniu composeAll(a, b, c) jako pierwsza uruchamiana jest skrajna prawa funkcja c, następnie b, a na końcu a. Odpowiada to zagnieżdżonej postaci a(b(c(x))).
Odczytanie tej kolejności może być trudne, dlatego niektórzy wolą potok od lewej do prawej.
Potok od lewej do prawej
pipe odwraca kolejność odczytywania: funkcje są uruchamiane od lewej do prawej, w kolejności zapisu. Dla wielu osób jest to łatwiejsze do śledzenia w potokach danych.
Pętla przechodzi do przodu, stosując każdą funkcję do aktualnej wartości.
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))Potok poprawiający czytelność
W przypadku pipe kolejne kroki są zapisane od góry do dołu, zgodnie z kolejnością wykonywania. Dzięki temu wieloetapowe przekształcenia stają się samodokumentujące.
W tym przypadku ciąg znaków jest pozbawiany prefiksu, zamieniany na małe litery, a następnie odwracany — każdy krok jest wymieniony w kolejności wykonywania.
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"))Kompozycja z użyciem domknięć
Można komponować funkcje utworzone przez częściową aplikację lub domknięcia. Należy budować małe, wyspecjalizowane funkcje, a następnie łączyć je ze sobą.
Dzięki temu każdą część można testować osobno, a kompozycja wyraża ogólny przebieg działania.
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))Kompozycja i potoki
Kompozycja jest spoiwem potoków danych. Zamiast głęboko zagnieżdżać wywołania, można raz nadać nazwę złożonej funkcji i zastosować ją do wielu danych wejściowych.
Doskonale współpracuje to z funkcją map: złożoną funkcję można przekazać jako przekształcenie wykonywane dla każdego elementu.
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, ", "))Funkcje powinny być małe
Kompozycja najlepiej sprawdza się w przypadku małych funkcji o jednym przeznaczeniu. Każda wykonuje jedno zadanie, a połączenie ich pozwala uzyskać złożone działanie bez ponownego pisania logiki.
To istota projektowania funkcyjnego: należy zbudować słownik niewielkich funkcji, a następnie komponować je w celu wyrażania większych koncepcji.
Szybkie sprawdzenie
Przed udzieleniem odpowiedzi należy dokładnie prześledzić kolejność.
Podsumowanie
Kompozycja łączy funkcje tak, aby wynik jednej z nich był przekazywany do następnej. compose(f, g) uruchamia najpierw g, a potem f, czyli od prawej do lewej, natomiast pipe działa od lewej do prawej, co poprawia czytelność.
Za pomocą composeAll i pipe można łączyć wiele małych funkcji w przejrzyste potoki, szczególnie skuteczne w połączeniu z funkcją map.
Często zadawane pytania
Czy lekcja „Komponowanie funkcji” jest bezpłatna?
Tak — pełny tekst „Komponowanie funkcji” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Lua Academy, przejdź na CoddyKit PRO. Kurs Lua Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Komponowanie funkcji”?
Połączy Pan/Pani przekształcenia w łańcuch. Ćwiczysz Lua Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Lua Academy?
Nie wymagamy żadnego doświadczenia. Lua Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.
Ile czasu zajmuje lekcja „Komponowanie funkcji”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Lua Academy?
Tak. Każda lekcja Lua Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Funkcje jako wartości
- map, filter, reduce
- Częściowe zastosowanie
- Komponowanie funkcji