Swift Academy · Lezione

Alternative non mutating

Restituisci nuovi valori invece di modificare quelli esistenti.

Alternative non mutating è 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.

Restituire invece di modificare

Invece di modificare un'istanza sul posto, un metodo non mutating può restituire un valore completamente nuovo con la modifica applicata.

struct Counter {
    var value: Int
    func incremented() -> Counter {
        return Counter(value: value + 1)
    }
}
let c = Counter(value: 0)
let next = c.incremented()
print(c.value, next.value)

L'originale resta invariato

Poiché non viene eseguita alcuna mutazione, il valore originale viene preservato e ne viene prodotto uno nuovo.

struct Vector {
    var x: Int
    var y: Int
    func scaled(by factor: Int) -> Vector {
        return Vector(x: x * factor, y: y * factor)
    }
}
let v = Vector(x: 2, y: 3)
let big = v.scaled(by: 10)
print(v.x, v.y, big.x, big.y)

Funziona sulle istanze let

I metodi non mutating possono essere chiamati sulle costanti let, poiché non modificano il ricevitore.

struct Money {
    var cents: Int
    func plus(_ other: Int) -> Money {
        return Money(cents: cents + other)
    }
}
let m = Money(cents: 100)
print(m.plus(50).cents)

Convenzione di denominazione

Convenzione di Swift: i metodi mutating usano verbi all'imperativo (sort), mentre quelli non mutating usano forme al participio passato o con -ed/-ing (sorted).

var nums = [3, 1, 2]
let ordered = nums.sorted()
nums.sort()
print(ordered, nums)

sorted e sort

La libreria standard segue questa convenzione: sorted() restituisce un nuovo array, mentre sort() modifica quello esistente.

let a = [5, 2, 8, 1]
let b = a.sorted()
print(a)
print(b)

reversed e reverse

Analogamente, reversed() è non mutating. In questo caso lo rendiamo un array concreto con Array.

let a = [1, 2, 3]
let b = Array(a.reversed())
print(a, b)

Concatenare chiamate non mutating

I metodi non mutating restituiscono valori, quindi è possibile concatenarli in modo fluido.

let result = [4, 2, 9, 1].sorted().map { $0 * 2 }
print(result)

Stile funzionale

Restituire nuovi valori invece di modificare quelli esistenti favorisce uno stile funzionale, facile da testare e da comprendere.

struct Account {
    var balance: Int
    func deposited(_ n: Int) -> Account {
        return Account(balance: balance + n)
    }
}
let a0 = Account(balance: 0)
let a1 = a0.deposited(100).deposited(50)
print(a0.balance, a1.balance)

Evitare i problemi dello stato condiviso

Produrre nuovi valori evita modifiche condivise accidentali, il che è particolarmente utile tra thread.

struct Settings {
    var volume: Int
    func with(volume newVolume: Int) -> Settings {
        return Settings(volume: newVolume)
    }
}
let base = Settings(volume: 5)
let loud = base.with(volume: 11)
print(base.volume, loud.volume)

Quando modificare invece

Se aggiorna ripetutamente una stessa istanza in un ciclo, la mutazione sul posto può essere più efficiente della creazione di molte copie.

var total = 0
for n in 1...5 {
    total += n
}
print(total)

Offrire entrambe le forme

I tipi ben progettati a volte offrono entrambe le forme, come la libreria standard, così chi li usa può scegliere tra la mutazione e un valore nuovo.

struct Text {
    var value: String
    func uppercased() -> Text {
        return Text(value: value.uppercased())
    }
    mutating func uppercase() {
        value = value.uppercased()
    }
}
var t = Text(value: "hi")
let u = t.uppercased()
t.uppercase()
print(u.value, t.value)

Verifica rapida

Verifichi la progettazione non mutating.

Riepilogo

In alternativa alla mutazione, un metodo non mutating restituisce un nuovo valore con la modifica applicata, lasciando intatto l'originale e funzionando sulle istanze let. La convenzione di Swift abbina i nomi all'imperativo (sort) ai nomi con -ed/-ing (sorted).

let a = [3, 1, 2]
let b = a.sorted()
print(a, b)

Domande Frequenti

La lezione «Alternative non mutating» è gratuita?

Sì — il testo completo di «Alternative non mutating» è 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 «Alternative non mutating»?

Restituisci nuovi valori invece di modificare quelli esistenti. 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 «Alternative non mutating»?

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