0Pricing
Swift Academy · Lezione

Compromessi tra lazy ed eager

Sai quando la valutazione lazy è utile o dannosa.

Compromessi tra lazy ed eager è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Niente è gratis

Lazy non è sempre più veloce. Scambia l'allocazione iniziale con un overhead a ogni accesso e modifica il momento in cui vengono eseguiti gli effetti collaterali. Conoscere questi compromessi permette di scegliere correttamente.

Lazy vince: consumo parziale

Serve solo una porzione di una trasformazione enorme — lazy salta il resto:

let data = Array(1...1_000_000)
let top = data.lazy.map { $0 * 2 }.prefix(3)
print(Array(top))  // [2, 4, 6]  -- 999,997 transforms skipped

Eager vince: riutilizzo completo

Se itera sul risultato molte volte, eager calcola una volta sola; lazy ricalcola a ogni passaggio:

let doubled = [1, 2, 3].map { $0 * 2 }  // computed once
print(doubled.reduce(0, +))  // 12
print(doubled.max()!)        // 6  -- no recompute

Lazy ricalcola

La stessa vista lazy ripete il lavoro a ogni iterazione:

var work = 0
let view = [1, 2, 3].lazy.map { (n: Int) -> Int in work += 1; return n }
_ = view.reduce(0, +)
_ = view.max()
print(work)  // 6  -- transformed twice

Overhead per elemento

Ogni passaggio lazy avvolge la sequenza in un altro tipo e invoca closure elemento per elemento. Per array molto piccoli, questo overhead può superare il risparmio di allocazione.

Array piccolo: eager va bene

Per pochi elementi consumati interamente, preferisca una soluzione eager semplice: l'allocazione è trascurabile:

let nums = [3, 1, 2]
let sorted = nums.map { $0 + 1 }.sorted()
print(sorted)  // [2, 3, 4]

La tempistica degli effetti collaterali cambia

Con lazy, il corpo della closure viene eseguito dopo la riga che la definisce. Eviti di fare affidamento sugli effetti collaterali nelle trasformazioni lazy:

var log: [Int] = []
let v = [1, 2].lazy.map { (n: Int) -> Int in log.append(n); return n }
print(log)        // []  -- nothing ran yet
_ = Array(v)
print(log)        // [1, 2]

Operazioni che impongono eager

Alcune operazioni devono comunque leggere l'intera sequenza, quindi lazy non offre alcun vantaggio:

let nums = Array(1...10)
print(nums.lazy.map { $0 * 2 }.sorted())  // sorted must see all -> [2,4,...,20]
print(nums.lazy.map { $0 }.count)         // count walks everything

Lazy con contains

Le operazioni con short-circuiting come contains(where:) traggono vantaggio da lazy con input grandi:

let big = Array(1...1_000_000)
let found = big.lazy.map { $0 * 2 }.contains { $0 == 8 }
print(found)  // true  -- stops at element 4

Una checklist per decidere

Usi lazy quando: la sorgente è grande E conserva solo una parte (prefix / first / contains) E itera una sola volta. Usi eager quando: l'array è piccolo, riutilizza il risultato o la leggibilità conta più della micro-ottimizzazione.

let huge = Array(1...100_000)
let first = huge.lazy.filter { $0 % 9973 == 0 }.first
print(first!)  // 9973

Misuri, non vada a intuito

L'intuizione sulle prestazioni è spesso ingannevole. Quando è importante, esegua un benchmark di entrambe le versioni con dati realistici prima di scegliere lazy.

let nums = Array(1...50)
let eager = nums.filter { $0 > 25 }.count
let lazyC = nums.lazy.filter { $0 > 25 }.count
print(eager == lazyC)  // true -- same answer, profile for speed

Verifica rapida

Quando è meglio scegliere eager invece di lazy?

Riepilogo

Ha imparato a conoscere i compromessi:

  • Lazy è vantaggioso con sorgenti grandi e un consumo parziale in un'unica passata
  • Eager è vantaggioso per array piccoli e risultati riutilizzati (lazy ricalcola)
  • Gli effetti collaterali nelle trasformazioni lazy vengono eseguiti in un secondo momento — eviti di dipendere da essi
  • Misuri prima di ottimizzare

Prossimo argomento: costruire sequenze lazy personalizzate.

Domande Frequenti

La lezione «Compromessi tra lazy ed eager» è gratuita?

Sì — il testo completo di «Compromessi tra lazy ed eager» è 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 «Compromessi tra lazy ed eager»?

Sai quando la valutazione lazy è utile o dannosa. 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 3 di 4.

Quanto tempo richiede la lezione «Compromessi tra lazy ed eager»?

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