Kompozycja
andThen i compose
Kompozycja to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 3 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 Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.
Łączenie funkcji
Kompozycja funkcji polega na tworzeniu nowej funkcji przez połączenie dwóch istniejących, tak aby wynik jednej stał się argumentem drugiej. Scala udostępnia do tego andThen i compose.
object Main {
def main(args: Array[String]): Unit = {
val addOne = (x: Int) => x + 1
val double = (x: Int) => x * 2
val both = addOne andThen double
println(both(5))
}
}andThen: od lewej do prawej
f andThen g wykonuje najpierw f, a następnie g. Czytanie od lewej do prawej odpowiada kolejności wykonywania, co dla wielu osób jest intuicyjne.
(f andThen g)(x) == g(f(x))
object Main {
def main(args: Array[String]): Unit = {
val addOne = (x: Int) => x + 1
val triple = (x: Int) => x * 3
val pipeline = addOne andThen triple
println(pipeline(4)) // (4 + 1) * 3
}
}compose: od prawej do lewej
f compose g wykonuje najpierw g, a następnie f, zgodnie z kolejnością matematyczną f(g(x)).
(f compose g)(x) == f(g(x))
object Main {
def main(args: Array[String]): Unit = {
val addOne = (x: Int) => x + 1
val triple = (x: Int) => x * 3
val pipeline = addOne compose triple
println(pipeline(4)) // (4 * 3) + 1
}
}andThen a compose
Te dwa operatory są swoimi lustrzanymi odbiciami:
f andThen g=g compose ff compose g=g andThen f
Należy wybrać ten zapis, który w danej sytuacji czyta się naturalniej.
object Main {
def main(args: Array[String]): Unit = {
val f = (x: Int) => x + 10
val g = (x: Int) => x * 2
println((f andThen g)(3))
println((g compose f)(3))
}
}Łączenie wielu funkcji
Można łączyć wiele funkcji za pomocą wielokrotnie użytego andThen, tworząc dłuższy potok przepływający od góry do dołu.
object Main {
def main(args: Array[String]): Unit = {
val clean = (s: String) => s.trim
val lower = (s: String) => s.toLowerCase
val bang = (s: String) => s + "!"
val process = clean andThen lower andThen bang
println(process(" HELLO "))
}
}Kompozycja zmienia typy
Typy komponowanych funkcji muszą być zgodne: typ wyniku pierwszej funkcji musi odpowiadać typowi argumentu drugiej. W trakcie działania potok może zmieniać typy.
object Main {
def main(args: Array[String]): Unit = {
val length = (s: String) => s.length
val isLong = (n: Int) => n > 5
val check = length andThen isLong
println(check("scala"))
println(check("functional"))
}
}Funkcja identycznościowa
identity zwraca swoje wejście bez zmian. Jest elementem neutralnym składania funkcji: f andThen identity == f. Przydatna jako wartość domyślna w operacjach fold i instrukcjach warunkowych.
object Main {
def main(args: Array[String]): Unit = {
val f = (x: Int) => x * 2
val same = f andThen identity[Int]
println(same(7))
}
}Składanie za pomocą reduce
Ponieważ funkcje są wartościami, można przechowywać kilka funkcji na liście i składać je wszystkie za pomocą reduce oraz andThen.
object Main {
def main(args: Array[String]): Unit = {
val steps: List[Int => Int] = List(_ + 1, _ * 2, _ - 3)
val pipeline = steps.reduce(_ andThen _)
println(pipeline(5)) // ((5+1)*2)-3
}
}Tworzenie wielokrotnego użytku potoków
Składanie zachęca do tworzenia małych funkcji realizujących pojedyncze zadania, które można łączyć w większe zachowania. To jedna z kluczowych idei programowania funkcyjnego.
object Main {
def main(args: Array[String]): Unit = {
val sanitize = (s: String) => s.trim.toLowerCase
val capitalize = (s: String) => s.capitalize
val format = sanitize andThen capitalize
println(format(" aLiCe "))
}
}Składanie z map
Złożona funkcja jest po prostu funkcją, więc można przekazać ją bezpośrednio do map, aby zastosować cały potok do elementów kolekcji.
object Main {
def main(args: Array[String]): Unit = {
val transform = ((x: Int) => x + 1) andThen ((x: Int) => x * x)
println(List(1, 2, 3).map(transform))
}
}Uważne odczytywanie kolejności składania
Częstym błędem jest mylenie andThen i compose. Zawsze należy pamiętać: andThen = najpierw ta funkcja, potem tamta; compose = odwrotnie.
object Main {
def main(args: Array[String]): Unit = {
val inc = (x: Int) => x + 1
val sqr = (x: Int) => x * x
println((inc andThen sqr)(2)) // (2+1)^2 = 9
println((inc compose sqr)(2)) // (2^2)+1 = 5
}
}Szybkie sprawdzenie
Mając funkcje f i g, co oblicza wyrażenie (f andThen g)(x)?
Podsumowanie
Opanowano składanie funkcji:
f andThen g→g(f(x))(od lewej do prawej)f compose g→f(g(x))(od prawej do lewej)- Są swoimi lustrzanymi odpowiednikami
identityjest elementem neutralnym- Listy funkcji można składać za pomocą
reduce(_ andThen _)
Często zadawane pytania
Czy lekcja „Kompozycja” jest bezpłatna?
Tak — pełny tekst „Kompozycja” 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 Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.
Co nauczysz się w „Kompozycja”?
andThen i compose Ćwiczysz Scala for Backend Engineering & Functional Programming 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ąć Scala for Backend Engineering & Functional Programming?
Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming 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 3 z 4.
Ile czasu zajmuje lekcja „Kompozycja”?
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 Scala for Backend Engineering & Functional Programming?
Tak. Każda lekcja Scala for Backend Engineering & Functional Programming 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.