如果是这样，是否存在在 Objective-C 中使用键值观察时不存在的任何关键差异？

最佳答案

您可以在 Swift 中使用 KVO，但仅限于 NSObject 子类的 dynamic 属性。假设您想观察 Foo 类的 bar 属性。在 Swift 4 中，将 bar 指定为 NSObject 子类中的 dynamic 属性:

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

然后您可以注册以观察 bar 属性的变化。在 Swift 4 和 Swift 3.2 中，这已大大简化，如 Using Key-Value Observing in Swift 中所述。 :

class MyObject {
    private var token: NSKeyValueObservation

    var objectToObserve = Foo()

    init() {
        token = objectToObserve.observe(\.bar) { [weak self] object, change in  // the `[weak self]` is to avoid strong reference cycle; obviously, if you don't reference `self` in the closure, then `[weak self]` is not needed
            print("bar property is now \(object.bar)")
        }
    }
}

请注意，在 Swift 4 中，我们现在使用反斜杠字符对键路径进行强类型化(\.bar 是对象的 bar 属性的键路径观察到的)。此外，因为它使用了完成闭包模式，我们不必手动移除观察者(当 token 超出范围时，观察者将被移除)也不必担心调用super 实现，如果键不匹配。仅当调用此特定观察者时才调用闭包。有关详细信息，请参阅 WWDC 2017 视频，What's New in Foundation .

在 Swift 3 中，为了观察这一点，它有点复杂，但与在 Objective-C 中所做的非常相似。也就是说，您将实现 observeValue(forKeyPath keyPath:, of object:, change:, context:) ，它 (a) 确保我们正在处理我们的上下文(而不是我们的 super 实例已注册观察)；然后 (b) 根据需要处理它或将其传递给 super 实现。并确保在适当的时候取消自己的观察员身份。例如，您可以在释放时删除观察者:

在 Swift 3 中:

class MyObject: NSObject {
    private var observerContext = 0

    var objectToObserve = Foo()

    override init() {
        super.init()

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

    deinit {
        objectToObserve.removeObserver(self, forKeyPath: #keyPath(Foo.bar), context: &observerContext)
    }

    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
        }

        // do something upon notification of the observed object

        print("\(keyPath): \(change?[.newKey])")
    }

}

请注意，您只能观察可以在 Objective-C 中表示的属性。因此，您无法观察泛型、Swift struct 类型、Swift enum 类型等。

有关 Swift 2 实现的讨论，请参阅下面我的原始回答。

使用 dynamic 关键字通过 NSObject 子类实现 KVO 在 Adopting Cocoa Design Conventions 的 Key-Value Observing 部分有描述。 Using Swift with Cocoa and Objective-C 指南的章节:

Key-value observing is a mechanism that allows objects to be notified of changes to specified properties of other objects. You can use key-value observing with a Swift class, as long as the class inherits from the NSObject class. You can use these three steps to implement key-value observing in Swift.

1. Add the dynamic modifier to any property you want to observe. For more information on dynamic, see Requiring Dynamic Dispatch.

   class MyObjectToObserve: NSObject {
       dynamic var myDate = NSDate()
       func updateDate() {
           myDate = NSDate()
       }
   }
   

2. Create a global context variable.

   private var myContext = 0
   

3. Add an observer for the key-path, and override the observeValueForKeyPath:ofObject:change:context: method, and remove the observer in deinit.

   class MyObserver: NSObject {
       var objectToObserve = MyObjectToObserve()
       override init() {
           super.init()
           objectToObserve.addObserver(self, forKeyPath: "myDate", options: .New, context: &myContext)
       }
   
       override func observeValueForKeyPath(keyPath: String?, ofObject object: AnyObject?, change: [String : AnyObject]?, context: UnsafeMutablePointer<Void>) {
           if context == &myContext {
               if let newValue = change?[NSKeyValueChangeNewKey] {
                   print("Date changed: \(newValue)")
               }
           } else {
               super.observeValueForKeyPath(keyPath, ofObject: object, change: change, context: context)
           }
       }
   
       deinit {
           objectToObserve.removeObserver(self, forKeyPath: "myDate", context: &myContext)
       }
   }
   

[请注意，此 KVO 讨论随后已从 Using Swift with Cocoa and Objective-C 指南中删除，该指南已针对 Swift 3 进行了改编，但它仍然按照顶部概述的方式工作这个答案。]

值得注意的是，Swift 有自己的原生 property observer系统，但这是针对指定其自己的代码的类，该代码将在观察其自身属性时执行。另一方面，KVO 旨在注册以观察其他类的某些动态属性的变化。

关于swift - Swift 中是否提供键值观察 (KVO)？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24092285/