PricingLoginStart free
Swift Academy · Lezione

La proprietà lazy

Rimandi il lavoro di trasformazione finché non è necessario.

Lezione 1 di 413 passaggi

La proprietà lazy è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Eager per impostazione predefinita

I metodi standard delle collection sono eager: map, filter e così via vengono eseguiti immediatamente e costruiscono subito un nuovo array completo, anche se si legge soltanto il primo elemento.

Il lavoro eager avviene subito

Questo codice costruisce in anticipo l'intero array trasformato:

let nums = [1, 2, 3, 4, 5]
let doubled = nums.map { $0 * 2 }  // whole array built now
print(doubled.first!)  // 2

La proprietà lazy

Ogni collection espone una vista .lazy. Le operazioni su una vista lazy sono differite: non vengono eseguite finché non si scorre la collection o non si richiede un elemento specifico.

Creare una vista lazy

È sufficiente anteporre .lazy alla concatenazione:

let nums = [1, 2, 3, 4, 5]
let view = nums.lazy.map { $0 * 2 }
// nothing computed yet
print(Array(view))  // [2, 4, 6, 8, 10]

Dimostrare l'esecuzione differita

Gli effetti collaterali mostrano che la closure viene eseguita solo su richiesta:

let nums = [1, 2, 3]
let lazyMapped = nums.lazy.map { n -> Int in
    print("transforming \(n)")
    return n * 2
}
print("created view")
print(lazyMapped.first!)  // prints "transforming 1" then 2

lazy restituisce un tipo diverso

Una concatenazione lazy è un wrapper leggero, non un Array:

let nums = [1, 2, 3]
let view = nums.lazy.map { $0 + 1 }
print(type(of: view).self != [Int].self)  // true -- it is a LazyMapSequence

Materializzare una vista lazy

Quando serve memorizzare o restituire il risultato, lo si può convertire nuovamente in un array concreto con Array(...):

let nums = [1, 2, 3]
let result: [Int] = Array(nums.lazy.map { $0 * 10 })
print(result)  // [10, 20, 30]

lazy e first(where:)

La valutazione lazy è vantaggiosa quando ci si ferma in anticipo. Vengono elaborati soltanto gli elementi necessari per trovare una corrispondenza:

let nums = [1, 2, 3, 4, 5, 6]
let firstBig = nums.lazy.map { $0 * $0 }.first { $0 > 10 }
print(firstBig!)  // 16  (stops at 4*4)

lazy su un intervallo

Anche gli intervalli funzionano con lazy, una soluzione utile per sequenze grandi o quasi infinite:

let firstThree = (1...1000).lazy.map { $0 * $0 }.prefix(3)
print(Array(firstThree))  // [1, 4, 9]

Quando la vista viene rivalutata

Una vista lazy ricalcola il risultato ogni volta che la si scorre — non memorizza alcun risultato. Se la si scorre due volte, la trasformazione viene eseguita due volte:

var calls = 0
let view = [1, 2].lazy.map { (n: Int) -> Int in calls += 1; return n }
_ = Array(view)
_ = Array(view)
print(calls)  // 4

Quando usare lazy

Aggiunga .lazy quando ha una concatenazione lunga ma consuma soltanto una parte del risultato — la prima corrispondenza, un prefisso o un singolo reduce. Per gli array piccoli consumati completamente, l'approccio eager è più semplice.

let nums = Array(1...100)
let result = nums.lazy.filter { $0 % 7 == 0 }.first
print(result!)  // 7

Verifica rapida

Che cosa cambia la proprietà .lazy nel comportamento di map e filter?

Rispondi nella lezione interattiva

Riepilogo

Ha appreso le basi delle operazioni lazy:

  • I metodi standard delle collection sono eager: costruiscono immediatamente gli array
  • .lazy restituisce una vista differita, cioè un tipo di sequenza speciale
  • Il lavoro viene eseguito soltanto quando si scorre la collection o si richiede un elemento
  • Si materializza il risultato con Array(...); le viste vengono ricalcolate a ogni iterazione

Prossimo argomento: concatenazioni lazy di map e filter.

Gratis per iniziare

Impara Swift con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi
122
Lezioni
409
Inizia a imparare gratisVisualizza il corso completo

Domande Frequenti

La lezione «La proprietà lazy» è gratuita?

Sì — il testo completo di «La proprietà 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 «La proprietà lazy»?

Rimandi il lavoro di trasformazione finché non è necessario. 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 1 di 4.

Quanto tempo richiede la lezione «La proprietà 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