Vérifier si une valeur est modifiée à l'aide de KVO dans Swift 3

Ci-dessous est ma première Swift 3 réponse, mais Swift 4 simplifie le processus, éliminant la nécessité d'une coulée. Par exemple, si vous observez les Int propriété appelée bar de la foo objet:

class Foo: NSObject {
    @objc dynamic var bar: Int = 42
}

class ViewController: UIViewController {

    let foo = Foo()
    var token: NSKeyValueObservation?

    override func viewDidLoad() {
        super.viewDidLoad()

        token = foo.observe(\.bar, options: [.new, .old]) { [weak self] object, change in
            if change.oldValue != change.newValue {
                self?.edit()
            }
        }
    }

    func edit() { ... }
}

Note, la fermeture de cette approche basée sur:

• Vous sort d'avoir à mettre en œuvre un distinct observeValue méthode;

• Élimine le besoin pour la spécification d'un context, et en vérifiant que le contexte; et

• La change.newValue et change.oldValue sont correctement typées, éliminant le besoin de manuel de la coulée. Si la propriété était une option, vous peut-être en toute sécurité les déballer, mais pas de conversion est nécessaire.

La seule chose que vous devez faire attention est de s'assurer que votre fermeture à ne pas introduire une forte cycle de référence (d'où l'utilisation de [weak self] modèle).

---

Ma première Swift 3 réponse est ci-dessous.

---

Vous dit:

Mais, en pensant à cela, je ne pense pas que cela va fonctionner pour les primitives de swift des objets tels que des Int qui (je suppose) n'héritent pas de NSObject et à la différence de l'Objective-C version ne sera pas en boîte en NSNumber lorsqu'il est placé dans le changement dictionnaire.

En fait, si vous regardez ces valeurs, si les observés de la propriété est un Int, il vient par le dictionnaire comme un NSNumber.

Vous pouvez soit rester dans le NSObject monde:

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    if let newValue = change?[.newKey] as? NSObject,
        let oldValue = change?[.oldKey] as? NSObject,
        !newValue.isEqual(oldValue) {
            edit()
    }
}

Ou de les utiliser comme NSNumber:

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    if let newValue = change?[.newKey] as? NSNumber,
        let oldValue = change?[.oldKey] as? NSNumber,
        newValue.intValue != oldValue.intValue {
            edit()
    }
}

Ou, je préfère, si c'était un Int valeur de certains dynamic propriété de certains Swift classe, je préfère aller de l'avant et de les jeter comme Int:

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    if let newValue = change?[.newKey] as? Int, let oldValue = change?[.oldKey] as? Int, newValue != oldValue {
        edit()
    }
}

---

Vous avez demandé:

Aussi, question bonus, comment puis-je faire usage de la of object variable? Il ne me laisse pas changer le nom et bien sûr, n'aime pas les variables avec les espaces.

La of est l'étiquette externe pour ce paramètre (utilisé lorsque vous étiez à l'appel de cette méthode; dans ce cas, le système d'exploitation appelle cela pour nous, donc nous n'utilisons pas cette étiquette externe à court de la signature de la méthode). Le object est sur l'étiquette interne (utilisé dans la méthode elle-même). Swift a eu la capacité pour les externes et internes des étiquettes pour les paramètres pendant un certain temps, mais il n'a été véritablement embrassé dans l'API de Swift 3.

En termes de lorsque vous utilisez cette change paramètre, vous l'utilisez si vous êtes en observant les propriétés de plus d'un objet, et si ces objets ont besoin d'un traitement différent sur le KVO, par exemple:

foo.addObserver(self, forKeyPath: #keyPath(Foo.bar), options: [.new, .old], context: &observerContext)
baz.addObserver(self, forKeyPath: #keyPath(Foo.qux), options: [.new, .old], context: &observerContext)

Et puis:

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    guard context == &observerContext else {
        super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
        return
    }

    if (object as? Foo) == foo {
        //handle `foo` related notifications here
    }
    if (object as? Baz) == baz {
        //handle `baz` related notifications here
    }
}

---

En aparté, j'avais recommandons généralement à l'aide de la context, par exemple, ont un private var:

private var observerContext = 0

Puis ajouter l'observateur à l'aide de ce contexte:

foo.addObserver(self, forKeyPath: #keyPath(Foo.bar), options: [.new, .old], context: &observerContext)

Et puis avoir mon observeValue assurez-vous qu'il a été son context, et pas celui établi par sa super-classe:

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    guard context == &observerContext else {
        super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
        return
    }

    if let newValue = change?[.newKey] as? Int, let oldValue = change?[.oldKey] as? Int, newValue != oldValue {
        edit()
    }
}

OriginalL'auteur Rob