PricingLoginStart free
Swift Academy · Lekcja

Właściwość lazy

Odroczone wykonywanie przekształceń do momentu, gdy będą potrzebne.

Lekcja 1 z 413 kroki

Właściwość lazy to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 1 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.

Eager jako tryb domyślny

Standardowe metody kolekcji działają w trybie eager: map, filter itd. uruchamiają się natychmiast i od razu tworzą całą nową tablicę, nawet jeśli odczytywany jest tylko pierwszy element.

Obliczenia eager odbywają się natychmiast

W tym przypadku cała przekształcona tablica jest tworzona z góry:

let nums = [1, 2, 3, 4, 5]
let doubled = nums.map { $0 * 2 }  // whole array built now
print(doubled.first!)  // 2

Właściwość lazy

Każda kolekcja udostępnia widok .lazy. Operacje na takim widoku są odroczone: nie wykonują się, dopóki kolekcja nie zostanie faktycznie przeiterowana lub dopóki nie zażąda się konkretnego elementu.

Tworzenie leniwego widoku

Wystarczy poprzedzić łańcuch elementem .lazy:

let nums = [1, 2, 3, 4, 5]
let view = nums.lazy.map { $0 * 2 }
// nothing computed yet
print(Array(view))  // [2, 4, 6, 8, 10]

Dowód odroczonego wykonania

Efekty uboczne pokazują, że closure jest uruchamiane dopiero na żądanie:

let nums = [1, 2, 3]
let lazyMapped = nums.lazy.map { n -> Int in
    print("transforming \(n)")
    return n * 2
}
print("created view")
print(lazyMapped.first!)  // prints "transforming 1" then 2

lazy zwraca inny typ

Leniwy łańcuch jest lekkim wrapperem, a nie tablicą Array:

let nums = [1, 2, 3]
let view = nums.lazy.map { $0 + 1 }
print(type(of: view).self != [Int].self)  // true -- it is a LazyMapSequence

Materializowanie leniwego widoku

Gdy trzeba przechować wynik lub go zwrócić, można przekształcić widok z powrotem w konkretną tablicę za pomocą Array(...):

let nums = [1, 2, 3]
let result: [Int] = Array(nums.lazy.map { $0 * 10 })
print(result)  // [10, 20, 30]

lazy i first(where:)

Leniwe obliczenia przynoszą korzyści, gdy kończy się pracę wcześniej. Przetwarzanych jest tylko tyle elementów, ile potrzeba do znalezienia dopasowania:

let nums = [1, 2, 3, 4, 5, 6]
let firstBig = nums.lazy.map { $0 * $0 }.first { $0 > 10 }
print(firstBig!)  // 16  (stops at 4*4)

lazy dla zakresu

Zakresy również współpracują z lazy, co jest przydatne w przypadku dużych lub niemal nieskończonych sekwencji:

let firstThree = (1...1000).lazy.map { $0 * $0 }.prefix(3)
print(Array(firstThree))  // [1, 4, 9]

Ponowna ewaluacja widoku

Leniwy widok oblicza wynik ponownie przy każdej iteracji — nie przechowuje wyników. Przy dwóch iteracjach transform jest wykonywany dwukrotnie:

var calls = 0
let view = [1, 2].lazy.map { (n: Int) -> Int in calls += 1; return n }
_ = Array(view)
_ = Array(view)
print(calls)  // 4

Kiedy sięgać po lazy

Warto dodać .lazy, gdy łańcuch jest długi, ale wykorzystywana jest tylko część wyniku — pierwsze dopasowanie, prefiks lub pojedyncza redukcja. W przypadku małych tablic, które są w całości wykorzystywane, tryb eager jest prostszy.

let nums = Array(1...100)
let result = nums.lazy.filter { $0 % 7 == 0 }.first
print(result!)  // 7

Szybkie sprawdzenie

Co właściwość .lazy zmienia w działaniu map i filter?

Odpowiedz w interaktywnej lekcji

Podsumowanie

W tej lekcji poznano podstawy leniwych obliczeń:

  • Standardowe metody kolekcji działają w trybie eager — natychmiast tworzą tablice
  • .lazy zwraca odroczony widok (specjalny typ sekwencji)
  • Praca odbywa się dopiero podczas iteracji lub żądania konkretnego elementu
  • Widok można zmaterializować za pomocą Array(...); przy każdej iteracji widoki wykonują obliczenia ponownie

Następnie: leniwe łańcuchy map i filter.

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łatnieWyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Właściwość lazy” jest bezpłatna?

Tak — pełny tekst „Właściwość lazy” 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 „Właściwość lazy”?

Odroczone wykonywanie przekształceń do momentu, gdy będą potrzebne. Ć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 1 z 4.

Ile czasu zajmuje lekcja „Właściwość lazy”?

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. Właściwość lazy
  2. Leniwe map i filter
  3. Kompromisy między leniwym a zachłannym wykonaniem
  4. Budowanie niestandardowych sekwencji leniwych
← Powrót do Swift Academy