Swift Academy · Lezione

Sequenze lazy per l’efficienza

Utilizzare .lazy per rimandare i calcoli ed evitare di creare array intermedi.

Sequenze lazy per l’efficienza è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Benvenuto

Le sequenze lazy rimandano l'elaborazione fino a quando i risultati sono necessari, evitando la creazione di array intermedi quando si concatenano più operazioni.

Il problema della valutazione eager

```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! ```

Aggiungere .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] ```

Tipi di collezioni lazy

Quando si chiama `.lazy` su una sequenza, Swift restituisce una `LazySequence` che la avvolge: ```swift let lazyArr = [1,2,3].lazy // LazySequence<[Int]> let lazyMap = lazyArr.map { $0*2 } // LazyMapSequence ```

Quando lazy è vantaggioso

La valutazione lazy è vantaggiosa quando: • È necessario solo un prefisso di una sequenza di grandi dimensioni • La sorgente è infinita, ad esempio nel caso di generatori personalizzati • Si concatenano molte trasformazioni su collezioni grandi

Sequenze infinite

```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 con first(where:)

```swift let firstEven = (1...Int.max) .lazy .first { $0 % 2 == 0 } // Returns 2 immediately — doesn't iterate the whole range ```

Forzare la valutazione

Per materializzare una sequenza lazy, la si avvolge in un Array: ```swift let eager = Array((1...100).lazy.filter { $0 % 3 == 0 }.map { $0*2 }) ```

Lazy non è sempre la scelta migliore

Per le collezioni piccole, lazy comporta un sovraccarico dovuto ai tipi wrapper. Eseguire un benchmark prima di applicare `.lazy` a ogni concatenazione. Utilizzarlo quando la collezione è grande e sono necessarie interruzioni anticipate.

Generatore lazy personalizzato

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

Verifica rapida

Che cosa permette di ottenere il prefisso `.lazy` in una catena di operazioni su una collezione?

Riepilogo

Concetti chiave: • `.lazy` rimanda l'elaborazione di map/filter fino al momento del consumo • Evita le allocazioni di array intermedi • È utile per sequenze grandi quando è necessario solo un prefisso • Combinare con `prefix` e `first(where:)` per interrompere prima l'elaborazione • Materializzare con `Array(lazySeq)` quando necessario Corso completato!

Domande Frequenti

La lezione «Sequenze lazy per l’efficienza» è gratuita?

Sì — il testo completo di «Sequenze lazy per l’efficienza» è 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 «Sequenze lazy per l’efficienza»?

Utilizzare .lazy per rimandare i calcoli ed evitare di creare 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 4 di 4.

Quanto tempo richiede la lezione «Sequenze lazy per l’efficienza»?

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

Funzioni pure e progettazione senza effetti collaterali
Funzioni di ordine superiore: map, flatMap, compactMap
Composizione di funzioni e pipeline
Sequenze lazy per l’efficienza

← Torna a Swift Academy