Funktioiden koostaminen
Ketjuttakaa muunnoksia.
Funktioiden koostaminen on ilmainen Lua Academy-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Lua Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Lua Academy-kurssilla on yhteensä 4 oppituntia.
Mitä funktioiden koostaminen on
Funktioiden koostaminen yhdistää kaksi funktiota yhdeksi. Koostettu funktio välittää syötteensä ensin ensimmäiselle funktiolle ja antaa tuloksen sitten toiselle.
Matematiikassa tämä kirjoitetaan muodossa f(g(x)). Koostamisen avulla suuria muunnoksia voi rakentaa pienistä, tarkasti rajatuista funktioista.
Kahden funktion koostaminen
compose-apufunktio ottaa kaksi funktiota ja palauttaa uuden funktion. Sen kutsuminen suorittaa ensin g-funktion ja välittää tuloksen sitten f-funktiolle.
Järjestyksellä on merkitystä: sisempi funktio suoritetaan ensin ja ulompi funktio käsittelee sen tuloksen.
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))Järjestyksellä on merkitystä
Argumenttien vaihtaminen muuttaa tulosta. compose(f, g) tarkoittaa, että ensin sovelletaan g:tä ja sitten f:ää.
Alla oleva esimerkki osoittaa, että ensin kaksinkertaistamalla ja sitten lisäämällä saadaan eri tulos kuin lisäämällä ensin ja kaksinkertaistamalla sen jälkeen.
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))Merkkijonofunktioiden koostaminen
Koostaminen toimii kaikilla yhden argumentin funktioilla, myös merkkijonojen muunnoksilla. Voit ketjuttaa tyhjien merkkien poistamisen, kirjainkoon muuttamisen tai kääntämisen yhdeksi uudelleenkäytettäväksi vaiheeksi.
Tässä reverse suoritetaan ensin ja upper sen jälkeen, jolloin tuloksena on isoilla kirjaimilla kirjoitettu käännetty merkkijono.
local function compose(f, g) return function(x) return f(g(x)) end end
local shout = compose(string.upper, string.reverse)
print(shout("lua"))Usean funktion koostaminen
Jos haluat ketjuttaa enemmän kuin kaksi funktiota, kirjoita vaihtuvan määrän argumentteja hyväksyvä composeAll. Se soveltaa funktioita oikealta vasemmalle sisäkkäisten kutsujen tapaan.
Silmukka käy funktiolistan takaperin ja välittää arvon vuorotellen jokaiselle funktiolle.
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))Oikealta vasemmalle
Funktiossa composeAll(a, b, c) oikeanpuoleisin funktio c suoritetaan ensin, sitten b ja lopuksi a. Tämä vastaa sisäkkäistä muotoa a(b(c(x))).
Järjestyksen hahmottaminen voi olla hankalaa, minkä vuoksi jotkut suosivat sen sijaan vasemmalta oikealle etenevää pipe-putkea.
Vasemmalta oikealle etenevä pipe
pipe kääntää lukusuunnan: funktiot suoritetaan vasemmalta oikealle siinä järjestyksessä kuin ne on kirjoitettu. Monien mielestä tätä on helpompi seurata tietoputkistoissa.
Silmukka etenee eteenpäin ja soveltaa kutakin funktiota käsiteltävänä olevaan arvoon.
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 selkeyttää lukemista
pipe-funktion avulla vaiheet luetaan ylhäältä alas suoritusjärjestyksessä. Tämä tekee monivaiheisista muunnoksista itsensä dokumentoivia.
Tässä merkkijonosta poistetaan etuliite, muutetaan se pieniksi kirjaimiksi ja käännetään lopuksi. Jokainen vaihe on lueteltu siinä järjestyksessä, jossa se suoritetaan.
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"))Koostaminen sulkeumien kanssa
Voit koostaa osittaisella soveltamisella tai sulkeumilla rakennettuja funktioita. Rakenna pieniä erikoistuneita funktioita ja yhdistä ne sitten toisiinsa.
Näin jokainen osa säilyy testattavana, samalla kun koostaminen ilmaisee kokonaisuuden kulun.
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))Koostaminen ja putkistot
Koostaminen toimii tietoputkistojen perustana. Syvästi sisäkkäisten kutsujen sijaan nimeät koostetun funktion kerran ja sovellat sitä useisiin syötteisiin.
Tämä toimii erinomaisesti map-funktion kanssa: välitä koostettu funktio alkioiden muunnokseksi.
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, ", "))Pitäkää funktiot pieninä
Koostaminen hyötyy pienistä, yhteen tarkoitukseen keskittyvistä funktioista. Kukin funktio tekee yhden asian, ja yhdistämällä niitä voitte muodostaa monimutkaista toimintaa kirjoittamatta logiikkaa uudelleen.
Tämä on funktionaalisen suunnittelun ydin: rakentakaa pienten funktioiden sanasto ja ilmaiskaa sen avulla suurempia kokonaisuuksia.
Pikatarkistus
Seuratkaa suoritusjärjestystä tarkasti ennen vastaamista.
Kertaus
Koostaminen yhdistää funktioita niin, että yhden tulos välitetään seuraavalle. compose(f, g) suorittaa ensin g:n ja sitten f:n oikealta vasemmalle, kun taas pipe etenee selkeyden vuoksi vasemmalta oikealle.
composeAll- ja pipe-funktioilla ketjutatte useita pieniä funktioita selkeiksi putkistoiksi, jotka ovat erityisen tehokkaita yhdessä map-funktion kanssa.
Opi Lua tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 40
- Oppitunnit
- 159
Usein kysytyt kysymykset
Onko oppitunti ”Funktioiden koostaminen” ilmainen?
Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Lua Academy-oppimispolun 3 oppituntia, myös oppitunnin “Funktioiden koostaminen”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Lua Academy-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”Funktioiden koostaminen”?
Ketjuttakaa muunnoksia. Harjoittelet Lua Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni Lua Academy-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin Lua Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.
Kuinka kauan ”Funktioiden koostaminen”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä Lua Academy-oppitunnilla?
Kyllä. Jokainen Lua Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Funktiot arvoina
- map, filter, reduce
- Osittainen soveltaminen
- Funktioiden koostaminen