Swift Academy · Lektion

Lata sekvenser för effektivitet

Använd .lazy för att skjuta upp beräkningar och undvika att skapa mellanliggande arrayer.

Lektion 4 av 412 steg

Lata sekvenser för effektivitet är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Swift Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Swift Academy innehåller totalt 4 lektioner.

Välkommen

Lata sekvenser skjuter upp beräkningen tills resultaten behövs och undviker därmed att mellanliggande arrayer skapas när operationer kedjas.

Problemet med omedelbar 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! ```

Lägga till .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] ```

Typer för lata samlingar

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

När lazy är fördelaktigt

Lazy evaluering är fördelaktig när: • Du bara behöver ett prefix av en stor sekvens • Källan är oändlig (anpassade generatorer) • Du kedjar många transformationer på stora samlingar

Oändliga 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 ```

Tvinga fram evaluering

Om du vill materialisera en lat sekvens omsluter du den med Array: ```swift let eager = Array((1...100).lazy.filter { $0 % 3 == 0 }.map { $0*2 }) ```

Lazy är inte alltid bäst

För små samlingar medför lazy en kostnad på grund av omslagstyperna. Mät prestandan innan du använder `.lazy` i varje kedja. Använd det när samlingen är stor och du behöver avbryta tidigt.

Anpassad lat generator

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

Snabbkontroll

Vad åstadkommer prefixet `.lazy` i en kedja av samlingsoperationer?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Viktigast att komma ihåg: • `.lazy` skjuter upp beräkningen av map/filter tills sekvensen konsumeras • Undviker allokering av mellanliggande arrayer • Användbart för stora sekvenser när bara ett prefix behövs • Kombinera med `prefix` och `first(where:)` för att avsluta tidigt • Materialisera med `Array(lazySeq)` när det behövs Kursen är klar!

Gratis att börja

Lär dig Swift med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 122
Lektioner: 409

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Lata sekvenser för effektivitet” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Swift Academy, inklusive ”Lata sekvenser för effektivitet”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Swift Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Lata sekvenser för effektivitet”?

Använd .lazy för att skjuta upp beräkningar och undvika att skapa mellanliggande arrayer. Ni övar på Swift Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Swift Academy?

Du behöver inga förkunskaper. Utbildningen i Swift Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Lata sekvenser för effektivitet”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Swift Academy-lektionen?

Ja. Varje Swift Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Rena funktioner och design utan sidoeffekter
Högre ordningens funktioner: map, flatMap, compactMap
Funktionskomposition och pipelines
Lata sekvenser för effektivitet

← Tillbaka till Swift Academy