Swift Academy · leksjon

Late sekvenser for effektivitet

Bruk .lazy til å utsette beregninger og unngå å opprette mellomliggende matriser.

Leksjon 4 av 412 trinn

Late sekvenser for effektivitet er en gratis leksjon i Swift Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Swift Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Velkommen

Late sekvenser utsetter beregningen til resultatene trengs, og unngår dermed å opprette mellomliggende arrayer når operasjoner lenkes sammen.

Problemet med eager evaluering

```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! ```

Legge til .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] ```

Late samlingstyper

Når du kaller `.lazy` på en sekvens, returnerer Swift en `LazySequence` som pakker den inn: ```swift let lazyArr = [1,2,3].lazy // LazySequence<[Int]> let lazyMap = lazyArr.map { $0*2 } // LazyMapSequence ```

Når lazy er best

Lazy evaluering er best når: • Du bare trenger et prefiks av en stor sekvens • Kilden er uendelig (egendefinerte generatorer) • Du lenker mange transformasjoner på store samlinger

Uendelige sekvenser

```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)) ```

Lazy med first(where:)

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

Tvinge frem evaluering

For å materialisere en lat sekvens pakker du den inn i Array: ```swift let eager = Array((1...100).lazy.filter { $0 % 3 == 0 }.map { $0*2 }) ```

Lazy er ikke alltid best

For små samlinger medfører lazy ekstra kostnader på grunn av wrapper-typene. Kjør ytelsesmålinger før du bruker `.lazy` på alle kjeder. Bruk det når samlingen er stor og du trenger tidlig avslutning.

Egendefinert lazy-generator

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

Rask sjekk

Hva oppnår prefikset `.lazy` i en samlingskjede?

Besvar den i den interaktive leksjonen

Oppsummering

Viktigste poenger: • `.lazy` utsetter map/filter-beregningen til sekvensen konsumeres • Unngår allokering av mellomliggende arrayer • Nyttig for store sekvenser når du bare trenger et prefiks • Kombiner med `prefix`, `first(where:)` for tidlig avslutning • Materialiser med `Array(lazySeq)` når det trengs Kurset er fullført!

Gratis å komme i gang

Lær deg Swift med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 122
Leksjoner: 409

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Late sekvenser for effektivitet» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Swift Academy, inkludert «Late sekvenser for effektivitet», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Late sekvenser for effektivitet»?

Bruk .lazy til å utsette beregninger og unngå å opprette mellomliggende matriser. Du øver på Swift Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Swift Academy?

Ingen tidligere erfaring er nødvendig. Swift Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Late sekvenser for effektivitet»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Swift Academy-leksjonen?

Ja. Alle Swift Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Rene funksjoner og utforming uten bivirkninger
Høyereordensfunksjoner: map, flatMap, compactMap
Funksjonssammensetning og pipelines
Late sekvenser for effektivitet

← Tilbake til Swift Academy