Swift Academy · Lekcja

Kompozycja funkcji i potoki

Budowanie potoków danych przez łączenie małych funkcji w większe przekształcenia.

Kompozycja funkcji i potoki to bezpłatna lekcja Swift Academy 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 Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

Kompozycja funkcji łączy małe, wyspecjalizowane funkcje w większe przekształcenia. Jest istotą programowania funkcyjnego — złożone działanie buduje się z prostych elementów.

Ręczna kompozycja

```swift func double(_ n: Int) -> Int { n * 2 } func addOne(_ n: Int) -> Int { n + 1 } let result = addOne(double(5)) // 11 ```

Kompozycja za pomocą funkcji pomocniczej

```swift func compose(_ f: @escaping (B)->C, _ g: @escaping (A)->B) -> (A)->C { { f(g($0)) } } let doubleAndAdd = compose(addOne, double) print(doubleAndAdd(5)) // 11 ```

Własny operator >>>

```swift infixop precedencegroup CompositionPrecedence { ... } func >>> (f: @escaping (A)->B, g: @escaping (B)->C) -> (A)->C { { g(f($0)) } } let pipeline = double >>> addOne >>> String.init print(pipeline(5)) // "11" ```

Potok z łańcuchem map/filter

```swift let process: ([Int]) -> [String] = { nums in nums.filter { $0 > 3 }.map { String($0 * 2) } } print(process([1,2,3,4,5])) // ["8","10"] ```

Styl point-free

Styl point-free pozwala uniknąć nazywania argumentów pośrednich: ```swift let words = ["hello","WORLD","Swift"] let lower = words.map { $0.lowercased() } // named let lower2 = words.map(\.description) // point-free where applicable ```

Ścieżki kluczy jako funkcje

Ścieżki kluczy Swift mogą być używane jako funkcje: ```swift struct User { var name: String } let users = [User(name:"Alice"),User(name:"Bob")] let names = users.map(\.name) // ["Alice","Bob"] ```

Budowanie potoku danych

```swift let pipeline: (String) -> Int? = { s in let trimmed = s.trimmingCharacters(in:.whitespaces) guard !trimmed.isEmpty else { return nil } return Int(trimmed) } [" 42 "," ","7"].compactMap(pipeline) // [42,7] ```

Częściowa aplikacja

```swift func add(_ a: Int) -> (Int) -> Int { { a + $0 } } let add5 = add(5) print([1,2,3].map(add5)) // [6,7,8] ```

Dlaczego kompozycja ma znaczenie

Korzyści: • Każda funkcja jest mała i łatwa do przetestowania • Potoki są czytelne od góry do dołu • Ponowne użycie: `double` działa samodzielnie lub w dowolnym potoku • Leniwe działanie: połącz z `.lazy`, aby uniknąć alokowania elementów pośrednich

Szybkie sprawdzenie

Która funkcja Swift umożliwia bezpośrednie używanie ścieżek kluczy jako funkcji transformujących w `map`?

Podsumowanie

Najważniejsze wnioski: • Komponuj małe funkcje w większe transformacje • `>>>` lub ręczna kompozycja umożliwiają tworzenie wielokrotnego użytku potoków • Ścieżki kluczy jako funkcje ułatwiają czytelne pobieranie właściwości • Częściowa aplikacja tworzy wyspecjalizowane funkcje • Połącz z `.lazy`, aby tworzyć potoki bez kopiowania danych Dalej: leniwe sekwencje.

Często zadawane pytania

Czy lekcja „Kompozycja funkcji i potoki” jest bezpłatna?

Tak — pełny tekst „Kompozycja funkcji i potoki” 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 Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Kompozycja funkcji i potoki”?

Budowanie potoków danych przez łączenie małych funkcji w większe przekształcenia. Ćwiczysz Swift 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ąć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift 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 3 z 4.

Ile czasu zajmuje lekcja „Kompozycja funkcji i potoki”?

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 Swift Academy?

Tak. Każda lekcja Swift 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

Czyste funkcje i projektowanie bez efektów ubocznych
Funkcje wyższego rzędu: map, flatMap, compactMap
Kompozycja funkcji i potoki
Leniwe sekwencje dla większej wydajności

← Powrót do Swift Academy