willSet e didSet in Swift: cosa sono, sintassi e funzionamento degli osservatori

Cosa sono willSet e didSet in Swift?

willSet e didSet sono osservatori di proprietà (property observers) in Swift, un meccanismo integrato per tracciare le modifiche delle stored properties.

A differenza di altri linguaggi che richiedono l'implementazione manuale di setter o sistemi di callback, Swift fornisce una sintassi dichiarativa per reagire ai cambiamenti. Gli osservatori vengono aggiunti direttamente dopo la dichiarazione della proprietà e non richiedono una chiamata separata.

Secondo la documentazione per sviluppatori Apple (2026), i property observers sono supportati per le stored properties di qualsiasi classe, struttura o enumerazione. Non funzionano con le computed properties perché queste non memorizzano un valore — per esse, la reazione al cambiamento è implementata direttamente nel setter.

Quando viene chiamato willSet

willSet viene chiamato immediatamente prima di assegnare un nuovo valore alla proprietà. All'interno di willSet, è disponibile il parametro implicito newValue, che contiene il valore che verrà impostato. In questo momento, il valore corrente della proprietà non è ancora cambiato — puoi leggere il vecchio valore direttamente attraverso la proprietà.

Secondo la proposta Swift Evolution SE-0001 (2024), willSet fornisce la possibilità di eseguire una validazione o registrazione prima del cambiamento effettivo. Se viene lanciata un'eccezione in willSet, il nuovo valore non verrà applicato, rendendo gli osservatori un meccanismo di protezione dei dati.

Quando viene chiamato didSet

didSet viene chiamato immediatamente dopo l'assegnazione di un nuovo valore. All'interno di didSet, è disponibile il parametro implicito oldValue, che contiene il valore prima del cambiamento. A questo punto, la proprietà contiene già il nuovo valore e puoi confrontarlo con quello vecchio.

Secondo Swift by Sundell (2025), didSet è l'osservatore più popolare perché è più spesso necessario per la post-elaborazione: aggiornare l'interfaccia utente, ricalcolare campi dipendenti o inviare dati al server dopo una modifica.

Sintassi degli osservatori di proprietà

I property observers vengono dichiarati immediatamente dopo la proprietà utilizzando le parentesi graffe. La sintassi minima richiede un solo osservatore, ma è possibile dichiararli entrambi.

var score: Int = 0 {
    willSet {
        print("Il punteggio cambierà in \(newValue)")
    }
    didSet {
        print("Il punteggio è cambiato da \(oldValue) a \(score)")
    }
}

Entrambi gli osservatori sono opzionali — puoi specificare solo willSet o solo didSet. Per willSet puoi rinominare newValue specificando un nome tra parentesi.

var username: String = "guest" {
    willSet(newName) {
        print("In procinto di impostare \(newName)")
    }
    didSet(oldName) {
        print("Era \(oldName), ora \(username)")
    }
}

Secondo Swift Language Guide (2026), rinominare i parametri migliora la leggibilità del codice, specialmente quando la proprietà e gli osservatori sono utilizzati in un progetto grande con nomi lunghi.

Come funzionano willSet e didSet

L'ordine di esecuzione è strettamente definito: prima willSet (il vecchio valore è disponibile), poi l'assegnazione, poi didSet (il nuovo valore è disponibile).

class Temperature {
    var celsius: Double = 0.0 {
        willSet {
            print("La temperatura cambierà da \(celsius) a \(newValue)")
        }
        didSet {
            if celsius > 100.0 {
                print("Punto di ebollizione superato!")
            }
        }
    }
}

Una limitazione importante: gli osservatori non vengono chiamati durante l'inizializzazione della proprietà quando si crea un'istanza. All'interno di init, l'assegnazione di un valore non attiva willSet e didSet — questo previene effetti collaterali indesiderati nella fase di costruzione.

Secondo l'Apple Swift Blog (2025), questo comportamento differisce da molti altri linguaggi in cui i setter vengono chiamati anche nei costruttori. Swift sceglie la sicurezza: gli osservatori iniziano a funzionare solo dopo il completamento dell'inizializzazione dell'oggetto.

Chiamate annidate e ricorsione

Modificare una proprietà all'interno di didSet può portare a chiamate ripetute dell'osservatore. Swift non blocca la ricorsione — il programmatore deve controllarla manualmente.

var counter: Int = 0 {
    didSet {
        if counter < 5 {
            counter += 1
        }
    }
}

Questo codice creerà una ricorsione totale con overflow dello stack se non viene fornita una condizione di uscita. Secondo la comunità Stack Overflow Swift (2025), questo è uno degli errori più comuni commessi dai principianti quando lavorano con i property observers.

Osservatori per le proprietà delle strutture

Le strutture supportano willSet e didSet per le stored properties senza restrizioni. È importante ricordare che le strutture sono tipi di valore e la modifica di una proprietà all'interno di un metodo mutante attiva anche gli osservatori.

struct Point {
    var x: Double = 0.0 {
        didSet {
            print("X è cambiato in \(x)")
        }
    }
    var y: Double = 0.0 {
        didSet {
            print("Y è cambiato in \(y)")
        }
    }
}

var point = Point()
point.x = 5.0

Utilizzo degli osservatori in progetti reali

Gli osservatori di proprietà vengono utilizzati nei progetti Swift per un'ampia gamma di attività: dalla sincronizzazione dell'interfaccia utente alla validazione dei dati e alla registrazione.

Validazione dei valori

didSet consente di annullare o correggere un valore non valido immediatamente dopo la sua impostazione. Questo sostituisce i setter ingombranti di Objective-C e garantisce l'integrità dei dati a livello di modello.

var age: Int = 0 {
    didSet {
        if age < 0 || age > 150 {
            age = oldValue
        }
    }
}

Sincronizzazione dell'interfaccia utente

Quando una proprietà correlata cambia, puoi aggiornare automaticamente gli elementi dell'interfaccia senza una chiamata separata al metodo di aggiornamento.

var userName: String = "" {
    didSet {
        nameLabel.text = userName
    }
}

Registrazione delle modifiche

willSet è utile per la registrazione a fini di debug o audit. Puoi registrare l'ora e il nuovo valore prima della sua applicazione, assicurando che il log contenga i dati originali per l'analisi.

Secondo objc.io (2025), i property observers sono particolarmente utili nelle architetture con flusso di dati unidirezionale, dove ogni modifica della proprietà viene registrata per la successiva riproduzione dello stato.

Confronto con le computed properties

Le computed properties calcolano un valore al volo e non hanno memorizzazione, mentre willSet e didSet lavorano su una stored property con un valore effettivo.

La differenza chiave: una computed property calcola un valore ad ogni accesso, mentre un property observer reagisce a un cambiamento di un valore esistente. La scelta tra di loro è dettata dalla semantica — se la proprietà è derivata da altri dati, usa computed; se è un valore indipendente di cui devono essere osservati i cambiamenti, usa willSet/didSet.

Errori comuni nell'utilizzo

L'errore più comune è la chiamata ricorsiva di didSet senza una condizione di uscita. Ogni modifica della proprietà all'interno di didSet attiva nuovamente l'osservatore, portando a un ciclo infinito.

Il secondo errore comune è tentare di utilizzare osservatori su proprietà let. Il compilatore Swift genererà un errore perché let è una costante.

Il terzo errore è ignorare che l'osservatore non viene chiamato durante l'inizializzazione. Gli sviluppatori che si aspettano l'attivazione di willSet all'interno di init ottengono un comportamento imprevisto.

Il quarto problema è applicare osservatori a proprietà nelle estensioni. Swift vieta di aggiungere willSet/didSet alle stored properties nelle estensioni.

Secondo Ray Wenderlich (2025), comprendere queste limitazioni aiuta a evitare bug nelle fasi iniziali e rende il codice Swift più prevedibile.