KVO 和 KVC

KVC

• 用 KVC 实现高阶消息传递

valueForKey: 有很多有用的特例，比如说 NSArray 和 NSSet 这样的容器类都覆盖了这个方法。valueForKey: 被传递给容器中得每一个对象，而不是对容器本身进行操作。结果会被添加进返回的容器中。这样，开发者能很方便的用一个容器创建另一个容器对象，比如像这样：

[objc]  view plain  copy
 print ?

1. NSArray *array = @[@"foo",@"bar",@"baz"];  
2. NSArray *capitals = [array valueForKey:@"capitalizedString"];  

方法 capitalizedString 被传递给 NSArray 中的每一项，并返回一个包含结果的新 NSArray 。把消息（capitalizedString）作为参数传递称为高阶消息传递（Higher Order Messaging）。多个消息可以用键路径传递：

[objc]  view plain  copy
 print ?

1. NSArray *array = @[@"foo",@"bar",@"baz"];  
2. NSArray *capitalLengths = [array valueForKeyPath:@"capitalizedString.length"];  

以上代码对 array 的每一个元素调用 capitalizedString ，然后调用 length ，在把返回值封装进 NSNumber 对象。结果被收集进名为 capitalLengths 的新数组。

• 容器操作符

KVC 还提供了很复杂的函数，比如说自动对一组数字求和或者求平均值。看一下这个例子：

[objc]  view plain  copy
 print ?

1. NSArray *array = @[@"foo",@"bar",@"baz"];  
2. NSUInteger totalLenth = [[array valueForKeyPath:@"@sum.length"] intValue];  

@sum 是一个操作符，对指定的属性（length）求和。注意，这种写法可能比等价的循环写法慢几百倍。

在处理有几千个或者几万个元素的数组时，性能问题通常会至关重要。除了 @sum ，在 IOS 开发者库的 Key-Value Coding Programming Guide 中还有很多其他的操作符。这些操作符在处理 Core Data 时尤其有用，而且比等价的循环写法快，因为它们优化为数据库查询操作。不过你不能创建自己的操作。

参考链接：Collection Operators

  KVC Collection Operators

KVO

KVO是Cocoa的一个重要机制，他提供了观察某一属性变化的方法，极大的简化了代码。这种观察－被观察模型适用于这样的情况，比方说根据A（数据类）的某个属性值变化，B（view类）中的某个属性做出相应变化。对于推崇MVC的cocoa而言，KVO应用的地方非常广泛。（这样的机制听起来类似Notification，但是notification是需要一个发送notification的对象，一般是notificationCenter，来通知观察者。而KVO是直接通知到观察对象。）

使用KVO时通常遵循如下的流程：

1、注册观察

[objc]  view plain  copy
 print ?

1. - (void)addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(voidvoid *)context;  

keyPath就是要观察的属性值，options给你观察键值变化的选择，而context方便传输你需要的数据（注意这是一个void型）

2、实现变化后的回调方法

[objc]  view plain  copy
 print ?

1. - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(voidvoid *)context  

change里存储了一些变化的数据，比如变化前的数据，变化后的数据；如果注册时context不为空，这里context就能接收到。

3、停止观察

[objc]  view plain  copy
 print ?

1. - (void)removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath  

是不是觉得和NSNotificationCenter很类似，确实是有很多类似之处，都是需要注册观察和移除观察等操作，可以对比着记忆。

说明示例：

创建一个每秒自动更新1000行的表格。

KVCTableViewCell.h

[objc]  view plain  copy

 print ?

1. @interface KVCTableViewCell : UITableViewCell  
2. - (id)initWithReuseIdentifier:(NSString*)identifier;  
3. @property (nonatomic, readwrite, strong) id object;  
4. @property (nonatomic, readwrite, copy) NSString *property;  
5. @end  

[objc]  view plain  copy
 print ?

1. @implementation KVCTableViewCell  
2.   
3. - (BOOL)isReady {  
4.   return (self.object && [self.property length] > 0);  
5. }  
6.   
7. - (void)update {  
8.   self.textLabel.text = self.isReady ?  
9.   [[self.object valueForKeyPath:self.property] description]  
10.   : @"";  
11. }  
12.   
13. - (id)initWithReuseIdentifier:(NSString *)identifier {  
14.   return [super initWithStyle:UITableViewCellStyleDefault  
15.               reuseIdentifier:identifier];  
16. }  
17.   
18. <strong>- (void)removeObservation {  
19.   if (self.isReady) {  
20.     [self.object removeObserver:self  
21.                      forKeyPath:self.property];  
22.   }  
23. }  
24.   
25. - (void)addObservation {  
26.   if (self.isReady) {  
27.     [self.object addObserver:self forKeyPath:self.property  
28.                      options:0   
29.                      context:(void*)self];  
30.   }  
31. }  
32.   
33. - (void)observeValueForKeyPath:(NSString *)keyPath   
34.                       ofObject:(id)object   
35.                         change:(NSDictionary *)change   
36.                        context:(voidvoid *)context {  
37.   if ((__bridge id)context == self) {  
38.     // Our notification, not our superclass’s  
39.       [self update];  
40.   }  
41.   else {  
42.     [super observeValueForKeyPath:keyPath ofObject:object   
43.                            change:change context:context];  
44.   }  
45. }  
46.   
47. - (void)dealloc {</strong>  
48.   if (_object && [_property length] > 0) {  
49.     [_object removeObserver:self  
50.                  forKeyPath:_property  
51.                     context:(voidvoid *)self];  
52.   }  
53. }  
54.   
55. - (void)setObject:(id)anObject {  
56.   <strong>[self removeObservation];</strong>  
57.   _object = anObject;  
58.   <strong>[self addObservation];</strong>  
59.   [self update];  
60. }  
61.   
62. - (void)setProperty:(NSString *)aProperty {  
63.   <strong>[self removeObservation];</strong>  
64.   _property = aProperty;  
65.   <strong>[self addObservation];</strong>  
66.   [self update];  
67. }  
68. @end  

KVCTableViewController.h

[objc]  view plain  copy

 print ?

1. @interface KVCTableViewController ()  
2. @property (readwrite, strong) RNTimer *timer;  
3. @property (readwrite, strong) NSDate *now;  
4. @end  
5.   
6. @implementation KVCTableViewController  
7.   
8. - (void)updateNow {  
9.   self.now = [NSDate date];  
10. }  
11.   
12. - (void)viewDidLoad {  
13.   [self updateNow];  
14.   
15.   __weak id weakSelf = self;  
16.   self.timer =  
17.       [RNTimer repeatingTimerWithTimeInterval:1  
18.                                         block:^{  
19.                                           [weakSelf updateNow];  
20.                                         }];  
21. }  
22.   
23.   
24. - (void)viewDidUnload {  
25.   self.timer = nil;  
26.   self.now = nil;  
27. }  
28.   
29. - (NSInteger)tableView:(UITableView *)tableView  
30.  numberOfRowsInSection:(NSInteger)section {  
31.   return 100;  
32. }  
33.   
34. - (UITableViewCell *)tableView:(UITableView *)tableView  
35.          cellForRowAtIndexPath:(NSIndexPath *)indexPath {  
36.     
37.   static NSString *CellIdentifier = @"KVCTableViewCell";  
38.     
39.   KVCTableViewCell *cell = [tableView  
40.              dequeueReusableCellWithIdentifier:CellIdentifier];  
41.     
42.   if (cell == nil) {  
43.     cell = [[KVCTableViewCell alloc]  
44.             initWithReuseIdentifier:CellIdentifier];  
45.     <strong>[cell setProperty:@"now"];  
46.     [cell setObject:self];</strong>  
47.   }  
48.       
49.   return cell;  
50. }  
51.   
52. @end  

在 KVCTableViewCell 中，我们根据请求用 addObservation 观察目标的属性。注册 KVO 时，要把 self 作为 context 指针传递，以便在回调中判断这是否是我们观察的事件。因为一个类只能有一个 KVO 回调，所以可能收到父类注册的属性变化事件。如果是这样，需要把回调传递给 super。不幸的是，我们不能总是传给 super，因为 NSObject 可能抛出异常。所以要用唯一的 context 来识别观察的事件。

在 KVCTableViewController 中，我们创建了一个属性 now，并且让表格单元观察此属性。每隔一秒，数据源都会更新一次。观察者就会得到通知，表格单元也会更新。这是灰常高效的，在任何时候，都只有一屏的表格单元，因为单元是可以重用的。

KVO 真正的威力表现在 [KVCTableViewController updateNow] 方法:

[objc]  view plain  copy
 print ?

1. - (void)updateNow {  
2.   self.now = [NSDate date];  
3. }  

唯一要做得就是更新数据。不需要操心谁在观察你，如果没有人观察你，那么就不存在任何 NSNotificationCenter 那样的开销。KVO 真正的优势就在于模型类不可思议的简洁性。只要用存取方法来修改实例变量，所有的观察机制都会自动生效，不需要付出任何成本。所有的复杂性都转移到了观察者而不是被观察者。无怪乎KVO在苹果的底层框架中越来越流行。

KVO 是如何实现的

键值观察通知依赖于NSKeyValueObserVing.h 中的两个方法：willChangeValueForKey: 和 didChangeValueForKey: 。在一个被观察值发生改变之前，willChangeValueForKey: 一定会被调用，继而 obserValueForKey: ofObject: change: context: 也会被调用。可以手动实现这些调用，但很少有人这么做。一般我们只在希望能控制回调的调用时机才会这么做。大部分情况下，改变通知会自动调用。

Object-C 中没有什么神奇的。即时是消息分发，一开始看起来很神秘，实际上也相当直观。然而，KVO确实有点魔法。调用 setNow: 时，系统还会已某种方式在中间插入 willChangeValueForKey: 、didChangValueForKe: 和 didChangeValueForKey: 和 observeValueForKeyPath: ofObject: change: context: 的调用。大家可能以为这是因为 setNow:是合成方法，有时候我们也能看到有人这么写代码：

[objc]  view plain  copy
 print ?

1. -(void)setNow:(NSDate *)now{  
2.     [self willChangeValueForKey:@"now"];//没有必要  
3.     _now = now;  
4.     [self didChangeValueForKey:@"now"];//没有必要  
5. }  

这是完全没有必要的代码，不要这么做，这样的话，KVO代码会被调用两次。KVO在调用存取方法之前总是调用 willChangeValueForKey: ，之后总是调用 didChangValueForKey: 。怎么做到的呢？答案是通过方法混写。第一次对一个对象调用 addObserver: forKeyPath: options: context: 时，框架会创建这个类的新的KVO子类，并将被观察对象转移为新子类的的对象。在这个KVO特殊子类中，Cocoa创建观察属性的设置方法，大致工作原理如下：

[objc]  view plain  copy
 print ?

1. -(void)setNow:(NSDate *)now{  
2.     [self willChangeValueForKey:@"now"];  
3.     [super setValue:now forKey:@"now"];  
4.     [self didChangeValueForKey:@"now"];  
5. }  

这种继承和方法注入是在运行时而不是编译时实现的。这就是正确命名如此重要的原因。只有在使用KVC命名约定时，KVO才能做到这一点。

tips:

  1、KVO方法混写不是很容易发现。它会覆盖class方法并返回原来的类。不过有时候我们能看到对NSKVONotifying_MYClass 而不是 MYClass 的引用。

2、建议尽量保守、简单地使用KVO，而且只在真正带来好处的地方使用。当需要大量的观察（几百个或者更多）的情况下，它的性能会比NSNotification好很多。

3、在存在复杂的相互依赖关系或者复杂的类继承层次的地方避免使用KVO。用委托和NSNotification 这种简单地解决方案，通常要比自作聪明地使用KVO解决方案要好。