Réponse.

Les observateurs de propriété en Swift permettent de réagir aux modifications de la valeur d'une propriété. Ce concept est apparu avec Swift pour améliorer la transparence du contrôle des modifications de données et automatiser la logique lors des changements.

Historique de la question :

Avant Swift, ce comportement était souvent implémenté manuellement via des setters ou des méthodes spéciales. En Swift, les observateurs sont devenus un outil standard du langage.

Problème :

Il est important pour le développeur de pouvoir capturer le moment de changement d’une propriété - par exemple, pour mettre à jour l’interface utilisateur ou valider des données. Sans observateurs, le code devenait plus encombrant et moins lisible.

Solution :

En Swift, deux observateurs principaux sont disponibles :

willSet est appelé avant la modification de la valeur
didSet est appelé après l’attribution d’une nouvelle valeur

Les observateurs peuvent être ajoutés à des propriétés stockées, sauf pour les propriétés lazy et les propriétés calculées.

Exemple de code :

class Temperature {
    var celsius: Double {
        willSet {
            print("La valeur sera bientôt", newValue)
        }
        didSet {
            print("La valeur était :", oldValue, ", et est devenue :", celsius)
        }
    }
    init(celsius: Double) {
        self.celsius = celsius
    }
}

let temp = Temperature(celsius: 22)
temp.celsius = 28 // Affichera willSet et didSet

Caractéristiques clés :

Dans l'observateur willSet, une variable spéciale newValue est disponible
Dans didSet — oldValue
Les observateurs ne sont pas appelés lors de l'initialisation de la propriété dans init

Questions piégées.

Peut-on ajouter des observateurs aux propriétés calculées ?

Non, on ne peut pas ajouter willSet et didSet aux propriétés calculées, car elles ont déjà leur propre getter et setter. L'utilisation de willSet/didSet est uniquement pertinente pour les propriétés stockées.

Les observateurs seront-ils appelés lors de la modification d'une propriété à l'intérieur d'un initialiseur ?

Non, les observateurs de propriété ne sont pas appelés pendant l'initialisation (init). Ils ne se déclenchent que lors de la modification de la valeur après la fin de init.

Que se passe-t-il lors de l'attribution de la valeur courante à elle-même, par exemple x = x ?

Les observateurs seront quand même appelés, même si la valeur de la propriété n’a pas changé ! Cela peut entraîner des exécutions logiques secondaires - soyez prudent.

var value: Int = 0 {
    didSet {
        print("didSet est toujours appelé !")
    }
}
value = value // didSet sera appelé

Erreurs typiques et anti-patterns

Dépendance aux effets secondaires : mettre en œuvre la logique métier uniquement dans didSet/willSet rend le code opaque
Mauvaise gestion des effets secondaires lors d'un changement "vide" de valeur, quand rien ne change
Utilisation d'observateurs pour les propriétés calculées au lieu de mettre en œuvre le comportement dans le setter

Exemple de la vie

Cas négatif

Un développeur a implémenté une mise à jour de l'interface dans didSet, mais n'a pas contrôlé le changement de valeur. L'interface utilisateur était mise à jour même lors d'une attribution "vide", ce qui a réduit les performances.

Avantages :

Mise en œuvre rapide, peu de code

Inconvénients :

Augmentation du nombre d'opérations inutiles, complexité du débogage

Cas positif

Dans didSet, une vérification de l'égalité entre l'ancienne et la nouvelle valeur était effectuée. La mise à jour de l'interface se produisait uniquement si la valeur avait réellement changé.