Swift Academy · Lezione

reduce e reduce(into:)

Ag greghi le collezioni in un unico valore.

reduce e reduce(into:) è 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.

Che cos'è reduce?

reduce riduce un'intera sequenza a un singolo valore combinando ripetutamente un accumulatore con ogni elemento.

Si fornisce un valore iniziale
E una closure (accumulator, element) -> accumulator

Sommare con reduce

L'esempio classico — sommare tutti i valori:

let nums = [1, 2, 3, 4]
let total = nums.reduce(0) { acc, x in acc + x }
print(total)  // 10

Forma abbreviata degli operatori

Quando la closure consiste semplicemente in un operatore, è possibile passare direttamente la funzione dell'operatore:

let nums = [1, 2, 3, 4]
print(nums.reduce(0, +))   // 10
print(nums.reduce(1, *))   // 24

Ridurre a un tipo diverso

Il tipo del risultato può essere diverso dal tipo degli elementi:

let words = ["a", "b", "c"]
let joined = words.reduce("") { $0 + $1.uppercased() }
print(joined)  // "ABC"

Trovare il massimo con reduce

Può calcolare aggregazioni oltre alle somme:

let nums = [3, 9, 2, 7]
let maxVal = nums.reduce(Int.min) { max($0, $1) }
print(maxVal)  // 9

Il costo di reduce

Il reduce normale crea un accumulatore completamente nuovo a ogni passaggio. Per tipi valore come String o Array, questo significa copiare l'intero accumulatore per ogni elemento — un lavoro O(n²) per input di grandi dimensioni.

Ecco reduce(into:)

reduce(into:) passa l'accumulatore come parametro inout, quindi lo modifica sul posto invece di copiarlo:

let nums = [1, 2, 2, 3, 3, 3]
let counts = nums.reduce(into: [Int: Int]()) { dict, n in
    dict[n, default: 0] += 1
}
print(counts)  // [1: 1, 2: 2, 3: 3]

Creare un array in modo efficiente

reduce(into:) dà il meglio di sé quando si accumulano elementi in una collection:

let nums = [1, 2, 3, 4, 5]
let evensSquared = nums.reduce(into: [Int]()) { result, n in
    if n % 2 == 0 { result.append(n * n) }
}
print(evensSquared)  // [4, 16]

reduce e reduce(into:)

Stesso risultato, caratteristiche di prestazione diverse:

let parts = ["a", "b", "c"]
let a = parts.reduce("") { $0 + $1 }            // copies each step
let b = parts.reduce(into: "") { $0 += $1 }    // mutates in place
print(a, b)  // abc abc

Raggruppare con reduce(into:)

Un pattern frequente: raggruppare gli elementi in base a una chiave:

let names = ["Ann", "Al", "Bo", "Cy"]
let byInitial = names.reduce(into: [Character: [String]]()) { dict, name in
    dict[name.first!, default: []].append(name)
}
print(byInitial[Character("A")]!)  // ["Ann", "Al"]

Scegliere tra i due

Usi reduce per accumulatori scalari poco costosi, come Int e Double. Usi reduce(into:) ogni volta che l'accumulatore è una collection o un altro tipo valore di grandi dimensioni, per evitare le copie.

let nums = [1, 2, 3]
print(nums.reduce(0, +))                          // scalar: plain reduce
print(nums.reduce(into: Set<Int>()) { $0.insert($1) }) // collection: into

Verifica rapida

Perché è preferibile usare reduce(into:) quando si crea un dizionario o un array?

Riepilogo

Ha imparato a eseguire riduzioni:

reduce(initial) { acc, x in ... } riduce una sequenza a un unico valore
Forma abbreviata dell'operatore: reduce(0, +)
reduce(into:) modifica un accumulatore inout; lo usi per le collection
È ideale per conteggi, raggruppamenti e unioni

Prossimo argomento: flatMap e concatenazione.

Domande Frequenti

La lezione «reduce e reduce(into:)» è gratuita?

Sì — il testo completo di «reduce e reduce(into:)» è 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 «reduce e reduce(into:)»?

Ag greghi le collezioni in un unico valore. 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 «reduce e reduce(into:)»?

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

← Torna a Swift Academy