Swift Academy · leksjon

Lazy map og filter

Kjed lazy-transformeringer uten mellomliggende arrayer.

Leksjon 2 av 413 trinn

Lazy map og filter er en gratis leksjon i Swift Academy på CoddyKit. Dette er leksjon 2 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.

Mellomliggende arrayer

Ivrige kjeder allokerer en ny array mellom hvert trinn. filter().map() på en stor array bygger to komplette arrayer, selv om De kanskje bare trenger noen få elementer.

Den ivrige allokeringen

Her opprettes to mellomliggende arrayer:

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]

Slå sammen trinn med lazy

En lazy-kjede slår sammen operasjonene: Hvert element går gjennom alle trinnene før neste element starter, slik at ingen mellomliggende array allokeres.

En lazy-kjede

Samme logikk, ingen mellomliggende arrayer:

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

Flyt element for element

Sporing viser overlappende kjøring i stedet for kjøring trinn for trinn:

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]

Tidlig avslutning sparer arbeid

Kombiner en lazy-kjede med first(where:) for å stoppe så snart De kan:

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 med prefix

Hent bare de første resultatene av en kostbar transformasjon:

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

Telle arbeid som hoppes over

En teller viser hvor få elementer som faktisk kjøres:

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

Lazy compactMap

compactMap har også en lazy-variant:

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

Kombinere mange trinn

Lange, sammenslåtte pipelines forblir uten allokeringer frem til de materialiseres:

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]

Når sammenslåing hjelper mest

Lazy-sammenslåing er en fordel når kilden er stor og De bare beholder en del av resultatet. Hvis De uansett bruker alt og bygger en array, blir besparelsen mindre, og eager kan være enklere å lese.

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

Kort sjekk

Hva unngår en lazy filter().map()-kjede som en ivrig kjede oppretter?

Besvar den i den interaktive leksjonen

Oppsummering

De har lært om lazy-kjeder:

Ivrige kjeder allokerer en array mellom hvert trinn
.lazy slår sammen trinnene; element for element, uten mellomliggende arrayer
Passer perfekt sammen med first(where:) og prefix for tidlig avslutning
Størst gevinst får De med en stor kilde og delvis bruk av resultatet

Deretter: avveininger mellom lazy og eager.

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 «Lazy map og filter» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Swift Academy, inkludert «Lazy map og filter», 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 «Lazy map og filter»?

Kjed lazy-transformeringer uten mellomliggende arrayer. 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 2 av 4.

Hvor lang tid tar leksjonen «Lazy map og filter»?

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

← Tilbake til Swift Academy