0Pricing
Swift Academy · Lezione

map e filter lazy

Concateni trasformazioni lazy senza array intermedi.

map e filter lazy è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Array intermedi

Le concatenazioni eager allocano un nuovo array tra ogni passaggio. Su un array di grandi dimensioni, filter().map() crea due array completi anche se potrebbero servire soltanto pochi elementi.

L'allocazione eager

Qui vengono creati due array intermedi:

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]

Fondere i passaggi con lazy

Una concatenazione lazy fonde le operazioni: ogni elemento attraversa tutti i passaggi prima che inizi l'elaborazione dell'elemento successivo, quindi non viene mai allocato alcun array intermedio.

Una concatenazione lazy

La stessa logica, senza array intermedi:

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

Flusso elemento per elemento

Il tracciamento mostra un'esecuzione intercalata, anziché per fasi successive:

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]

L'uscita anticipata riduce il lavoro

Combini una concatenazione lazy con first(where:) per interromperla non appena possibile:

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

Prendere soltanto i primi risultati di una trasformazione costosa:

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

Contare il lavoro evitato

Un contatore dimostra quanti pochi elementi vengono elaborati:

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

compactMap lazy

Esiste una forma lazy anche di compactMap:

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

Combinare molti passaggi

Le pipeline lunghe e fuse non effettuano allocazioni finché non vengono materializzate:

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]

Quando la fusione è più vantaggiosa

La fusione lazy è vantaggiosa quando la sorgente è grande e si conserva soltanto una parte del risultato. Se si consuma comunque l'intero risultato in un array, il risparmio diminuisce e l'approccio eager può risultare più leggibile.

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

Verifica rapida

Che cosa evita una concatenazione lazy di filter().map() che invece una concatenazione eager crea?

Riepilogo

Ha imparato a usare le concatenazioni lazy:

  • Le concatenazioni eager allocano un array tra ogni passaggio
  • .lazy fonde i passaggi, elaborando un elemento alla volta e senza intermedi
  • Si abbina perfettamente a first(where:) e prefix per interrompere l'elaborazione in anticipo
  • Il vantaggio maggiore si ottiene con una sorgente grande e un consumo parziale

Prossimo argomento: compromessi tra lazy ed eager.

Domande Frequenti

La lezione «map e filter lazy» è gratuita?

Sì — il testo completo di «map e filter lazy» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «map e filter lazy»?

Concateni trasformazioni lazy senza array intermedi. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «map e filter lazy»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. La proprietà lazy
  2. map e filter lazy
  3. Compromessi tra lazy ed eager
  4. Creazione di sequenze lazy personalizzate
← Torna a Swift Academy