Comment utiliser les Property Observers en Swift

Les Property Observers servent à éxécuter du code à chaque fois qu’une propriété change.

Pendant longtemps je n’ai jamais utilisé ça et sous-estimé ça mais ça peut être utile quand on sait s’en servir.

willSet et didSet

willSet et didSet sont comme des fonctions qu’on appelerait avant ou après le changement d’une propriété.

Ça peut par exemple servir à mettre à jour un UILabel quand on change la propriété.

willSet est appelée avant et didSet est appelée après le changement de la valeur.

Vous pouvez accéder aux valeurs qu’il y avait avant et après dans la propriété dans ces closures :

var name = "" {
    willSet {
        print("Will change to \(newValue)")
    }

    didSet {
        print("Changed from \(oldValue) to \(score)")
    }
}

name = "Bob"

Les Computed Properties (Propriétés calculées)

Ces propriétés n’ont pas vraiment de valeurs. Elles ont juste un getter et un setter qui sont optionnels et qui définissent les actions qui sont faites quand on essaye de récupérer la valeur de cette propriété et quand on ajoute une valeur à cette propriété.

Voici un exemple :

struct Point {
    var x: Double
    var y: Double
}

struct Segment {
    var a: Point
    var b: Point
    var size: Double
    var center: Point {
        get {
            let x = (b.x - a.x) / 2
            let y = (b.y - a.y) / 2
            return Point(x: x, y: y)
        }
        set(newCenter) {
            a = Point(x: newCenter.x - size/2, y: newCenter.y - size/2)
            b = Point(x: newCenter.x + size/2, y: newCenter.y + size/2)
        }
    }
}

Dans cet exemple, si je crée une instance de Segment et que j’accède à la propriété center, je vais avoir un Point calculé à partir du point a et du point b.

À l’inverse, quand je change le center, je recalcule les propriétés a et b.

Les KeyPaths

Créer un KeyPath correspond à utiliser la méthode didSet qu’on a vu juste avant.

À la seule différence que là, on n’éxécutera pas le code à chaque changement de la propriété de toutes les instances mais d’une seule.

Grâce aux KeyPath on peut définir un didSet en dehors de la définition de la classe ou structure.

Par exemple, si je suis dans un UITableViewController et que je veux appeler la fonction reloadData de la tableView quand je change une propriété d’une instance d’une classe, alors je peux utiliser un KeyPath.

Si j’ai cette structure :

@objc class User: NSObject {
    @objc dynamic var name = ""
}

Je peux utiliser les KeyPath de cette façon :

let user = User()

user.observe(\User.name, options: .new) { user, change in
    print("Je m'appelle \(change.name)")
    tableView.reloadData() // Pour reprendre notre exemple
}

Conclusion

J’espère que mes exemples ont été suffisament clairs et concrets pour te montrer à quel point les Property Observers peuvent être utiles.