0Pricing
Swift Academy · Lekcja

Leniwe sekwencje dla większej wydajności

Używanie .lazy w celu odroczenia obliczeń i uniknięcia tworzenia tablic pośrednich.

Leniwe sekwencje dla większej wydajności to bezpłatna lekcja Swift 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 Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

Leniwe sekwencje odraczają obliczenia do momentu, gdy wyniki są potrzebne, dzięki czemu podczas łączenia operacji nie powstają tablice pośrednie.

Problem z zachłanną ewaluacją

```swift let result = (1...1_000_000) .filter { $0 % 7 == 0 } // creates array of ~142857 elements .map { $0 * 2 } // creates another 142857-element array .prefix(5) // Wasteful — only 5 elements needed! ```

Dodawanie .lazy

```swift let result = (1...1_000_000) .lazy .filter { $0 % 7 == 0 } .map { $0 * 2 } .prefix(5) // Only computes what prefix(5) needs — no intermediate arrays! print(Array(result)) // [14,28,42,56,70] ```

Typy leniwych kolekcji

Po wywołaniu `.lazy` na sekwencji Swift zwraca typ `LazySequence`, który ją opakowuje: ```swift let lazyArr = [1,2,3].lazy // LazySequence<[Int]> let lazyMap = lazyArr.map { $0*2 } // LazyMapSequence ```

Kiedy leniwe działanie się opłaca

Leniwa ewaluacja sprawdza się, gdy: • Potrzebują Państwo tylko prefiksu dużej sekwencji • Źródło jest nieskończone (niestandardowe generatory) • Łączą Państwo wiele transformacji na dużych kolekcjach

Nieskończone sekwencje

```swift struct Fibonacci: Sequence { func makeIterator() -> some IteratorProtocol { var a = 0, b = 1 return AnyIterator { let next = a; a = b; b = next + b; return next } } } let first10 = Array(Fibonacci().prefix(10)) ```

Leniwe przetwarzanie z first(where:)

```swift let firstEven = (1...Int.max) .lazy .first { $0 % 2 == 0 } // Returns 2 immediately — doesn't iterate the whole range ```

Wymuszanie ewaluacji

Aby zmaterializować leniwą sekwencję, opakuj ją w Array: ```swift let eager = Array((1...100).lazy.filter { $0 % 3 == 0 }.map { $0*2 }) ```

Leniwe działanie nie zawsze się opłaca

W przypadku małych kolekcji leniwe działanie wiąże się z narzutem wynikającym z typów opakowujących. Przed zastosowaniem `.lazy` do każdego łańcucha należy wykonać testy wydajności. Należy używać go wtedy, gdy kolekcja jest duża i potrzebne jest wcześniejsze zakończenie przetwarzania.

Niestandardowy leniwy generator

```swift func naturals() -> AnyIterator { var n = 0 return AnyIterator { n += 1; return n } } Array(naturals().prefix(5)) // [1,2,3,4,5] ```

Szybkie sprawdzenie

Co zapewnia prefiks `.lazy` w łańcuchu operacji na kolekcji?

Podsumowanie

Najważniejsze wnioski: • `.lazy` odracza obliczanie operacji map/filter do momentu użycia sekwencji • Unika alokowania tablic pośrednich • Jest przydatne w przypadku dużych sekwencji, gdy potrzebny jest tylko prefiks • Połącz z `prefix` i `first(where:)`, aby wcześniej zakończyć przetwarzanie • Zmaterializuj za pomocą `Array(lazySeq)`, gdy jest to potrzebne Kurs ukończony!

Często zadawane pytania

Czy lekcja „Leniwe sekwencje dla większej wydajności” jest bezpłatna?

Tak — pełny tekst „Leniwe sekwencje dla większej wydajności” 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 sekwencje dla większej wydajności”?

Używanie .lazy w celu odroczenia obliczeń i uniknięcia tworzenia 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 4 z 4.

Ile czasu zajmuje lekcja „Leniwe sekwencje dla większej wydajności”?

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

  1. Czyste funkcje i projektowanie bez efektów ubocznych
  2. Funkcje wyższego rzędu: map, flatMap, compactMap
  3. Kompozycja funkcji i potoki
  4. Leniwe sekwencje dla większej wydajności
← Powrót do Swift Academy