Swift Academy · Lekcja

Leniwe map i filter

Łączenie leniwych przekształceń bez tablic pośrednich.

Lekcja 2 z 413 kroki

Leniwe map i filter to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 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.

Tablice pośrednie

Łańcuchy eager przydzielają nową tablicę między każdym krokiem. filter().map() na dużej tablicy tworzy dwie pełne tablice, mimo że potrzebnych może być tylko kilka elementów.

Przydzielanie w trybie eager

W tym miejscu tworzone są dwie tablice pośrednie:

let nums = Array(1...6)
let result = nums
    .filter { $0 % 2 == 0 }  // builds [2, 4, 6]
    .map { $0 * 10 }         // builds [20, 40, 60]
print(result)  // [20, 40, 60]

Łączenie kroków za pomocą lazy

Leniwy łańcuch łączy operacje: każdy element przechodzi przez wszystkie kroki, zanim rozpocznie się przetwarzanie następnego, więc nie jest przydzielana żadna tablica pośrednia.

Leniwy łańcuch

Ta sama logika, zero tablic pośrednich:

let nums = Array(1...6)
let result = nums.lazy
    .filter { $0 % 2 == 0 }
    .map { $0 * 10 }
print(Array(result))  // [20, 40, 60]

Przepływ element po elemencie

Śledzenie wykonania pokazuje przeplatanie operacji zamiast wykonywania ich etapami:

let out = [1, 2, 3].lazy
    .filter { n -> Bool in print("filter \(n)"); return n > 1 }
    .map   { n -> Int  in print("map \(n)");    return n }
print(Array(out))  // filter 1, filter 2, map 2, filter 3, map 3 -> [2, 3]

Wczesne zakończenie oszczędza pracę

Połączenie leniwego łańcucha z first(where:) pozwala zakończyć pracę tak szybko, jak to możliwe:

let nums = Array(1...1_000_000)
let hit = nums.lazy.map { $0 + 1 }.first { $0 > 5 }
print(hit!)  // 6  -- only a handful of elements processed

lazy z prefix

Pobieranie tylko kilku pierwszych wyników kosztownego przekształcenia:

let squares = (1...).lazy.map { $0 * $0 }
print(Array(squares.prefix(5)))  // [1, 4, 9, 16, 25]

Zliczanie pominiętej pracy

Licznik pokazuje, jak niewiele elementów zostało przetworzonych:

var transforms = 0
let result = Array(1...100).lazy
    .map { (n: Int) -> Int in transforms += 1; return n * 2 }
    .prefix(3)
_ = Array(result)
print(transforms)  // 3, not 100

Leniwe compactMap

compactMap również ma leniwą postać:

let raw = ["1", "x", "3", "y", "5"]
let first = raw.lazy.compactMap { Int($0) }.first
print(first!)  // 1

Łączenie wielu kroków

Długie połączone potoki nie wymagają przydzielania pamięci aż do momentu materializacji:

let r = Array(1...20).lazy
    .filter { $0 % 2 == 0 }
    .map { $0 * $0 }
    .filter { $0 > 50 }
print(Array(r))  // [64, 100, 144, 196, 256, 324, 400]

Kiedy łączenie operacji daje największe korzyści

Leniwe łączenie operacji przynosi korzyści, gdy źródło jest duże, a zachowywana jest tylko część wyniku. Jeśli i tak całość jest pobierana do tablicy, oszczędności maleją, a tryb eager może zapewnić czytelniejszy kod.

let big = Array(1...10_000)
let sample = Array(big.lazy.filter { $0 % 1000 == 0 })
print(sample)  // [1000, 2000, ... 10000]

Szybkie sprawdzenie

Czego unika leniwy łańcuch filter().map(), co tworzy jego wersja eager?

Odpowiedz w interaktywnej lekcji

Podsumowanie

W tej lekcji poznano leniwe łańcuchy:

Łańcuchy eager przydzielają tablicę między każdym krokiem
.lazy łączy kroki — element po elemencie, bez obiektów pośrednich
Idealnie współpracuje z first(where:) i prefix, umożliwiając wcześniejsze zakończenie
Największe korzyści pojawiają się przy dużym źródle i częściowym wykorzystaniu wyników

Następnie: kompromisy między lazy i eager.

Bezpłatny start

Ucz się Swift dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 122
Lekcje: 409

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Leniwe map i filter” jest bezpłatna?

Tak — pełny tekst „Leniwe map i filter” 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 „Leniwe map i filter”?

Łączenie leniwych przekształceń bez tablic pośrednich. Ć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 2 z 4.

Ile czasu zajmuje lekcja „Leniwe map i filter”?

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

Właściwość lazy
Leniwe map i filter
Kompromisy między leniwym a zachłannym wykonaniem
Budowanie niestandardowych sekwencji leniwych

← Powrót do Swift Academy