Antwoord.

In Swift zijn structuren (struct) standaard value types: wanneer een instantie van een structuur wordt gekopieerd, wordt er een onafhankelijke kopie gemaakt. Echter, in tegenstelling tot klassen, kunnen de methoden van een structuur self en haar eigenschappen niet wijzigen zonder directe toestemming van de compiler. In eerdere versies van de talen C en C++ waren structuren altijd wijzigbaar, wat leidde tot onverwachte neveneffecten. Swift verhoogt de veiligheid door te vereisen dat methoden die de toestand van de structuur wijzigen expliciet worden gemarkeerd met het sleutelwoord mutating.

Het probleem doet zich voor als een methode nodig is om eigenschappen van de structuur te wijzigen, maar deze als normaal is gedeclareerd, en de compiler dit niet toestaat. Zonder mutating is het niet mogelijk om self of zijn eigenschappen te wijzigen.

De oplossing is om dergelijke methoden te declareren met behulp van het sleutelwoord mutating, wat de compiler een signaal geeft om de wijziging van self en de geneste eigenschappen toe te staan.

Codevoorbeeld:

struct Counter {
    var value = 0
    mutating func increment() {
        value += 1
    }
    // Deze methode zal NIET compileren als mutating wordt verwijderd
}

var counter = Counter()
counter.increment() // value is nu 1

Belangrijkste kenmerken:

Alleen methoden met mutating kunnen self en zijn eigenschappen wijzigen.
Mutating methoden kunnen niet worden aangeroepen op constanten (let-instanties).
In structuren kan self volledig worden vervangen binnen een mutating methode.

Lastige vragen.

1. Kun je mutating methoden aanroepen op een structuur die is gedeclareerd met let?

Nee, dat kan niet. Constante let waarden van structuren kunnen niet worden gewijzigd, zelfs niet met mutating methoden.

let counter = Counter()
counter.increment() // Compilatiefout

2. Kunnen geneste eigenschappen van een klasse binnen een structuur worden gewijzigd binnen een mutating methode van de structuur?

Ja, als de eigenschap van de structuur een reference type is (bijvoorbeeld een klasse), kunnen de interne eigenschappen worden gewijzigd zonder mutating, maar de gehele structuur alleen via mutating.

class State {
    var value = 0
}
struct Wrapper {
    var state = State()
    mutating func change() {
        state.value += 1
    }
}

3. Is het mogelijk om alleen een computed property binnen een methode zonder mutating te wijzigen?

Nee. Als de computed property een set heeft, vereist het wijzigen van zijn waarde binnen een methode nog steeds mutating.

Typische fouten en anti-patterns

Vergeten om de methode als mutating te declareren, wat de compilatie van wijzigingen van eigenschappen belemmert.
Structuren gebruiken op plaatsen waar vaak een wijziging van de toestand vereist is - in dergelijke gevallen is een klasse beter.
De bijzonderheden van het kopiëren van structuren negeren bij wijzigingen.

Voorbeeld uit het leven

Negatieve case

In een project is een eenvoudige teller geïmplementeerd op een structuur, maar de ontwikkelaar vergat de methode als mutating te markeren. De tests falen omdat de waarde niet verandert.

Voordelen:

Functionaliteit snel gerealiseerd.

Nadelen:

De ontwikkelaar begrijpt de fout niet, verliest tijd met het uitzoeken van de oorzaak.
Wijzigingen worden niet opgeslagen, wat tot verwarring in de code leidt.

Positieve case

Methoden in de structuur zijn gemarkeerd als mutating, de tests slagen, de wijzigingen worden correct bijgewerkt. Code is begrijpelijk voor alle teamleden.