willSet en didSet in Swift: wat is het, syntax en werking van waarnemers

Wat zijn willSet en didSet in Swift?

willSet en didSet zijn property observers (eigenschapswaarnemers) in Swift, een ingebouwd mechanisme voor het volgen van wijzigingen in stored properties.

In tegenstelling tot andere talen waar handmatige implementatie van setters of callback-systemen vereist is, biedt Swift een declaratieve syntax om te reageren op wijzigingen. Waarnemers worden direct na de declaratie van de eigenschap toegevoegd en vereisen geen aparte aanroep.

Volgens Apple Developer Documentation (2026) worden property observers ondersteund voor stored properties van elke klasse, structuur of enumeratie. Ze werken niet met computed properties, omdat deze geen waarde opslaan — voor hen wordt de reactie op wijziging direct in de setter geïmplementeerd.

Wanneer wordt willSet aangeroepen

willSet wordt direct vóór het toewijzen van de nieuwe waarde aan de eigenschap aangeroepen. Binnen willSet is de impliciete parameter newValue beschikbaar, die de waarde bevat die zal worden ingesteld. Op dit moment is de huidige waarde van de eigenschap nog niet gewijzigd — u kunt de oude waarde rechtstreeks via de eigenschap lezen.

Volgens Swift Evolution proposal SE-0001 (2024) biedt willSet de mogelijkheid om validatie of logging uit te voeren vóór de daadwerkelijke wijziging. Als er in willSet een uitzondering wordt gegenereerd — wordt de nieuwe waarde niet toegepast, wat waarnemers een mechanisme voor gegevensbescherming maakt.

Wanneer wordt didSet aangeroepen

didSet wordt direct na het toewijzen van de nieuwe waarde aangeroepen. Binnen didSet is de impliciete parameter oldValue beschikbaar, die de waarde vóór de wijziging bevat. Op dit moment bevat de eigenschap al de nieuwe waarde en kunt u deze met de oude vergelijken.

Volgens Swift by Sundell (2025) is didSet de populairste waarnemer, omdat deze het vaakst nodig is voor nabewerking: UI-update, herberekening van afhankelijke velden of het verzenden van gegevens naar de server na een wijziging.

Syntax van eigenschapswaarnemers

Property observers worden direct na de eigenschap gedeclareerd met accolades. Minimale syntax vereist slechts één waarnemer, maar beide kunnen worden gedeclareerd.

var score: Int = 0 {
    willSet {
        print("Score verandert naar \(newValue)")
    }
    didSet {
        print("Score veranderd van \(oldValue) naar \(score)")
    }
}

Beide waarnemers zijn optioneel — u kunt alleen willSet of alleen didSet specificeren. Voor willSet kan newValue worden hernoemd door de naam tussen haakjes op te geven.

var username: String = "guest" {
    willSet(newName) {
        print("Op het punt om \(newName) in te stellen")
    }
    didSet(oldName) {
        print("Was \(oldName), nu \(username)")
    }
}

Volgens Swift Language Guide (2026) verbetert het hernoemen van parameters de leesbaarheid van code, vooral wanneer de eigenschap en waarnemers worden gebruikt in een groot project met lange namen.

Hoe willSet en didSet werken

De uitvoervolgorde is strikt bepaald: eerst willSet (oude waarde is beschikbaar), dan toewijzing, dan didSet (nieuwe waarde is beschikbaar).

class Temperature {
    var celsius: Double = 0.0 {
        willSet {
            print("Temperatuur verandert van \(celsius) naar \(newValue)")
        }
        didSet {
            if celsius > 100.0 {
                print("Kookpunt overschreden!")
            }
        }
    }
}

Belangrijke beperking: waarnemers worden niet aangeroepen bij initialisatie van de eigenschap tijdens het maken van een instantie. Binnen init activeert het toewijzen van een waarde willSet en didSet niet — dit voorkomt ongewenste neveneffecten in de constructiefase.

Volgens Apple Swift Blog (2025) verschilt dit gedrag van veel andere talen waar setters zelfs in constructors worden aangeroepen. Swift kiest voor veiligheid: waarnemers beginnen pas te werken na voltooiing van de objectinitialisatie.

Geneste aanroepen en recursie

Het wijzigen van een eigenschap binnen didSet kan leiden tot herhaalde aanroep van waarnemers. Swift blokkeert recursie niet — de programmeur moet dit zelf controleren.

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

Zulke code zal totale recursie met stack-overflow creëren als er geen exit-voorwaarde is voorzien. Volgens Stack Overflow Swift Community (2025) is dit een van de meest voorkomende fouten van beginnende programmeurs bij het werken met property observers.

Waarnemers voor eigenschappen van structuren

Structuren ondersteunen willSet en didSet voor stored properties zonder beperkingen. Het is belangrijk te onthouden dat structuren value types zijn en dat het wijzigen van een eigenschap binnen een muterende methode ook waarnemers activeert.

struct Point {
    var x: Double = 0.0 {
        didSet {
            print("X veranderd naar \(x)")
        }
    }
    var y: Double = 0.0 {
        didSet {
            print("Y veranderd naar \(y)")
        }
    }
}

var point = Point()
point.x = 5.0

Toepassing van waarnemers in echte projecten

Eigenschapswaarnemers worden in Swift-projecten gebruikt voor een breed scala aan taken: van UI-synchronisatie tot gegevensvalidatie en logging.

Waardevalidatie

didSet maakt het mogelijk om een ongeldige waarde direct na het instellen terug te draaien of te corrigeren. Dit vervangt omslachtige setters in Objective-C en zorgt voor gegevensintegriteit op modelniveau.

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

UI-synchronisatie

Bij wijziging van een gerelateerde eigenschap kunnen interface-elementen automatisch worden bijgewerkt zonder aparte aanroep van een updatemethode.

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

Wijzigingen loggen

willSet is handig voor logging met het oog op debugging of audit. U kunt de tijd en de nieuwe waarde vóór toepassing vastleggen, zodat het log de originele gegevens voor analyse bevat.

Volgens objc.io (2025) zijn property observers vooral nuttig in architecturen met een unidirectionele gegevensstroom, waarbij elke eigenschapswijziging wordt vastgelegd voor later herstel van de toestand.

Vergelijking met computed properties

Computed properties berekenen de waarde ter plekke en hebben geen opslag, terwijl willSet en didSet werken op een stored property met een werkelijke waarde.

Het belangrijkste verschil: computed property berekent de waarde bij elke toegang, terwijl property observer reageert op wijziging van een bestaande waarde. De keuze ertussen wordt bepaald door semantiek — als de eigenschap is afgeleid van andere gegevens, gebruik dan computed; als het een onafhankelijke waarde is waarvan de wijzigingen moeten worden geobserveerd, gebruik dan willSet/didSet.

Veelvoorkomende fouten bij gebruik

De meest voorkomende fout — recursieve aanroep van didSet zonder exit-voorwaarde. Elke wijziging van de eigenschap binnen didSet activeert de observer opnieuw, wat leidt tot een oneindige lus.

De tweede veelvoorkomende fout — poging om waarnemers te gebruiken op let-eigenschappen. De Swift-compiler geeft een foutmelding, omdat let een constante is.

De derde fout — het negeren van het feit dat de observer niet wordt aangeroepen bij initialisatie. Ontwikkelaars die verwachten dat willSet binnen init wordt geactiveerd, krijgen onverwacht gedrag.

Het vierde probleem — het toepassen van waarnemers op eigenschappen in een extension. Swift verbiedt het toevoegen van willSet/didSet aan stored properties in een extension.

Volgens Ray Wenderlich (2025) helpt het begrijpen van deze beperkingen om bugs in vroege stadia te voorkomen en maakt het code in Swift voorspelbaarder.