iOS KVC和KVO详解

KVC定义

KVC键值编码，就是指iOS的开发中，可以允许开发者通过Key名直接访问对象的属性，或者给对象的属性赋值。而不需要调用明确的存取方法。这样就可以在运行时动态地访问和修改对象的属性。而不是在编译时确定，这也是ios开发中的黑魔法之一。很多高级的ios开发技巧都是基于KVC实现的。

在实现了访问器方法的类中，使用点语法和KVC访问对象其实差别不大，二者可以任意混用。但是没有访问起方法的类中，点语法无法使用，这时KVC就有优势了。

KVC的定义都是对NSObject的扩展来实现的，Objective-C中有个显式的NSKeyValueCoding类别名，所以对于所有继承了NSObject的类型，都能使用KVC(一些纯Swift类和结构体是不支持KVC的，因为没有继承NSObject)，下面是KVC最为重要的四个方法：

- (nullable id)valueForKey:(NSString *)key;                          //直接通过Key来取值

- (void)setValue:(nullable id)value forKey:(NSString *)key;          //通过Key来设值

- (nullable id)valueForKeyPath:(NSString *)keyPath;                  //通过KeyPath来取值

- (void)setValue:(nullable id)value forKeyPath:(NSString *)keyPath;  //通过KeyPath来设值

NSKeyValueCoding类别中其他的一些方法：

+ (BOOL)accessInstanceVariablesDirectly;
//默认返回YES，表示如果没有找到Set方法的话，会按照_key，_iskey，key，iskey的顺序搜索成员，设置成NO就不这样搜索

- (BOOL)validateValue:(inout id __nullable * __nonnull)ioValue forKey:(NSString *)inKey error:(out NSError **)outError;
//KVC提供属性值正确性�验证的API，它可以用来检查set的值是否正确、为不正确的值做一个替换值或者拒绝设置新值并返回错误原因。

- (NSMutableArray *)mutableArrayValueForKey:(NSString *)key;
//这是集合操作的API，里面还有一系列这样的API，如果属性是一个NSMutableArray，那么可以用这个方法来返回。

- (nullable id)valueForUndefinedKey:(NSString *)key;
//如果Key不存在，且没有KVC无法搜索到任何和Key有关的字段或者属性，则会调用这个方法，默认是抛出异常。

- (void)setValue:(nullable id)value forUndefinedKey:(NSString *)key;
//和上一个方法一样，但这个方法是设值。

- (void)setNilValueForKey:(NSString *)key;
//如果你在SetValue方法时面给Value传nil，则会调用这个方法

- (NSDictionary<NSString *, id> *)dictionaryWithValuesForKeys:(NSArray<NSString *> *)keys;
//输入一组key,返回该组key对应的Value，再转成字典返回，用于将Model转到字典。

同时苹果对一些容器类比如NSArray或者NSSet等，KVC有着特殊的实现。

有序集合对应方法如下：

-countOf<Key>//必须实现，对应于NSArray的基本方法count:2  -objectInAtIndex:

-<key>AtIndexes://这两个必须实现一个，对应于 NSArray 的方法 objectAtIndex: 和 objectsAtIndexes:

-get<Key>:range://不是必须实现的，但实现后可以提高性能，其对应于 NSArray 方法 getObjects:range:

-insertObject:in<Key>AtIndex:

-insert<Key>:atIndexes://两个必须实现一个，类似于 NSMutableArray 的方法 insertObject:atIndex: 和 insertObjects:atIndexes:

-removeObjectFrom<Key>AtIndex:

-remove<Key>AtIndexes://两个必须实现一个，类似于 NSMutableArray 的方法 removeObjectAtIndex: 和 removeObjectsAtIndexes:

-replaceObjectIn<Key>AtIndex:withObject:

-replace<Key>AtIndexes:with<Key>://可选的，如果在此类操作上有性能问题，就需要考虑实现之

无序集合对应方法如下：

-countOf<Key>//必须实现，对应于NSArray的基本方法count:

-objectIn<Key>AtIndex:

-<key>AtIndexes://这两个必须实现一个，对应于 NSArray 的方法 objectAtIndex: 和 objectsAtIndexes:

-get<Key>:range://不是必须实现的，但实现后可以提高性能，其对应于 NSArray 方法 getObjects:range:

-insertObject:in<Key>AtIndex:

-insert<Key>:atIndexes://两个必须实现一个，类似于 NSMutableArray 的方法 insertObject:atIndex: 和 insertObjects:atIndexes:

-removeObjectFrom<Key>AtIndex:

-remove<Key>AtIndexes://两个必须实现一个，类似于 NSMutableArray 的方法 removeObjectAtIndex: 和 removeObjectsAtIndexes:

-replaceObjectIn<Key>AtIndex:withObject:

-replace<Key>AtIndexes:with<Key>://这两个都是可选的，如果在此类操作上有性能问题，就需要考虑实现之

通过以下几个方面讲解KVC相关的技术概念以及使用：

• KVC设值
• KVC取值
• KVC使用keyPath
• KVC处理异常
• KVC处理数值和结构体类型属性
• KVC键值验证（Key-Value
  Validation）
• KVC处理集合
• KVC处理字典

KVC设值

KVC要设值，那么就要对象中对应的key，那KVC在内部是按什么样的顺序来寻找key的呢？当调用

setValue：属性值 forKey：@”name“

底层的执行机制如下

• 程序优先调用set:属性值方法，代码通过setter方法完成设置。注意：这里的是指成员变量名，首字母大小写需遵守KVC命名规则。
• 如果没有找到set:方法，就会调用+ (BOOL)accessInstanceVariablesDirectly，默认返回YES
• 紧接着会搜索该类里有不有名为的成员变量
• 如果没有，继续查看_ --> _is --> --> is,按这样的顺序查找下去
• 如果都没有，就会调用setValue：forUndefinedKey：方法，默认是抛出异常。

而第二步如果你重写方法让其返回NO，那么在这一步KVC会执行setValue：forUnderfinedKey：方法，不过一般开发者不会这样做。

举例：

#import 

@interface Test: NSObject {
    NSString *_name;
}

@end

@implementation Test

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        //生成对象
        Test *obj = [[Test alloc] init];
        //通过KVC赋值name
        [obj setValue:@"xiaoming" forKey:@"name"];
        //通过KVC取值name打印
        NSLog(@"obj的名字是%@", [obj valueForKey:@"name"]);
        //obj的名字是xiaoming
        
    }
    return 0;
}

再看一下设置accessInstanceVariablesDirectly为NO的效果：

#import 

@interface Test: NSObject {
    NSString *_name;
}

@end

@implementation Test

+ (BOOL)accessInstanceVariablesDirectly {
    return NO;
}

- (id)valueForUndefinedKey:(NSString *)key {
    NSLog(@"出现异常，该key不存在%@",key);
    return nil;
}

- (void)setValue:(id)value forUndefinedKey:(NSString *)key {
    NSLog(@"出现异常，该key不存在%@", key);
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        //生成对象
        Test *obj = [[Test alloc] init];
        //通过KVC赋值name
        [obj setValue:@"xiaoming" forKey:@"name"];
        //通过KVC取值name打印
        NSLog(@"obj的名字是%@", [obj valueForKey:@"name"]);
        
    }
    return 0;
}

打印结果:
出现异常，该key不存在name
出现异常，该key不存在name
obj的名字是(null）

可以看到accessInstanceVariablesDirectly为NO的时候KVC只会查询setter和getter这一层，下面寻找key的相关变量执行就会停止，直接报错。

设置accessInstanceVariablesDirectly为YES，再修改_name为_isName，看看执行是否成功。

#import 

@interface Test: NSObject {
    NSString *_isName;
}

@end

@implementation Test

+ (BOOL)accessInstanceVariablesDirectly {
    return YES;
}

- (id)valueForUndefinedKey:(NSString *)key {
    NSLog(@"出现异常，该key不存在%@",key);
    return nil;
}

- (void)setValue:(id)value forUndefinedKey:(NSString *)key {
    NSLog(@"出现异常，该key不存在%@", key);
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        //生成对象
        Test *obj = [[Test alloc] init];
        //通过KVC赋值name
        [obj setValue:@"xiaoming" forKey:@"name"];
        //通过KVC取值name打印
        NSLog(@"obj的名字是%@", [obj valueForKey:@"name"]);
        
    }
    return 0;
}

打印结果
obj的名字是xiaoming

从打印可以看到设置accessInstanceVariablesDirectly为YES，KVC会继续按照顺序查找，并成功设值和取值了。

KVC取值

当调用

valueForKey：@”name“

其搜素方式如下：

• 首先按照get,,is的顺序方法查找getter方法，找到的话会直接调用。如果是BOOL或者Int等值类型， 会将其包装成一个NSNumber对象。
• 如果上面的getter方法没有找到，KVC则会查找countOf,objectIn AtIndex或 AtIndexes，如果找到任意一个，那么就会返回一个代理集合（可以响应NSArray所有方法，它是NSKeyValueArray）给这个代理集合发送属于NSArray的方法，就会以countOf,objectInAtIndex或AtIndexes这几个方法组合的形式调用。
• 如果上面的方法没有找到，那么会同时调用countOf，enumeratorOf,memberOf格式的方法。如果这三个方法都找到，那么就返回一个可以响应NSSet的所有方法的代理集合，和上面一样，给这个代理集合发NSSet的消息，就会以countOf，enumeratorOf,memberOf组合的形式调用。
• 如果还没有，就检查类方法+ (BOOL)accessInstanceVariablesDirectly，默认返回yes，接着就会按_,_is,,is的顺序搜素成员变量名，这里不推荐这么做，因为这样直接访问实例变量破坏了封装性，如果重写方法返回NO，就会调用valueForUndefinedKey:方法，默认是抛出异常。

举例：

#import 

@interface Test: NSObject {
}

@end

@implementation Test

- (NSUInteger)getAge {
    return 10;
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        //生成对象
        Test *obj = [[Test alloc] init];
        //通过KVC取值age打印
        NSLog(@"obj的年龄是%@", [obj valueForKey:@"age"]);
        //obj的年龄是10
    }
    return 0;
}

可以看到[obj valueForKey:@"age"]，找到了getAge方法，并且取到了值。

下面把getAge改为age，举例如下：

#import 

@interface Test: NSObject {
}

@end

@implementation Test

- (NSUInteger)age {
    return 10;
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        //生成对象
        Test *obj = [[Test alloc] init];
        //通过KVC取值age打印
        NSLog(@"obj的年龄是%@", [obj valueForKey:@"age"]);
        //obj的年龄是10
    }
    return 0;
}

可以看到[obj valueForKey:@"age"]，找到了age方法，并且取到了值。

下面把getAge改成isAge，例子如下：

#import 

@interface Test: NSObject {
}

@end

@implementation Test

- (NSUInteger)isAge {
    return 10;
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        //生成对象
        Test *obj = [[Test alloc] init];
        //通过KVC取值age打印
        NSLog(@"obj的年龄是%@", [obj valueForKey:@"age"]);
        //obj的年龄是10
    }
    return 0;
}

以看到[obj valueForKey:@"age"]，找到了isAge方法，并且取到了值。

上面的代码说明了说明了KVC在调用valueforKey:@"age"时搜索key的机制。

KVC使用keyPath

在开发过程中，一个类的成员变量有可能是自定义类或其他的复杂数据类型，你可以先用KVC获取该属性，然后再次用KVC来获取这个自定义类的属性，
但这样是比较繁琐的，对此，KVC提供了一个解决方案，那就是键路径keyPath。顾名思义，就是按照路径寻找key。

- (nullable id)valueForKeyPath:(NSString *)keyPath;                  //通过KeyPath来取值
- (void)setValue:(nullable id)value forKeyPath:(NSString *)keyPath;  //通过KeyPath来设值

举例：

#import 

@interface Test1: NSObject {
    NSString *_name;
}
@end

@implementation Test1
@end

@interface Test: NSObject {
    Test1 *_test1;
}

@end

@implementation Test
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        //Test生成对象
        Test *test = [[Test alloc] init];
        //Test1生成对象
        Test1 *test1 = [[Test1 alloc] init];
        //通过KVC设值test的"test1"
        [test setValue:test1 forKey:@"test1"];
        //通过KVC设值test的"test1的name"
        [test setValue:@"xiaoming" forKeyPath:@"test1.name"];
        //通过KVC取值age打印
        NSLog(@"test的\"test1的name\"是%@", [test valueForKeyPath:@"test1.name"]);
        //test的"test1的name"是xiaoming
    }
    return 0;
}

从打印结果来看我们成功的通过keyPath设置了test1的值。
KVC对于keyPath是搜索机制第一步就是分离key，用小数点.来分割key，然后再像普通key一样按照先前介绍的顺序搜索下去。

KVC处理异常

KVC中最常见的异常就是不小心使用了错误的key，或者在设置中不小心传递了nil的值，KVC中有专门的方法来处理这些异常。

KVC处理nil异常

通常情况下，KVC不允许你要在调用setValue：属性值 forKey：(或者keyPath)时对非对象传递一个nil的值。很简单，因为值类型是不能为nil的。如果你不小心传了，KVC会调用setNilValueForKey:方法。这个方法默认是抛出异常，所以一般而言最好还是重写这个方法。

#import 

@interface Test: NSObject {
    NSUInteger age;
}

@end

@implementation Test

- (void)setNilValueForKey:(NSString *)key {
    NSLog(@"不能将%@设成nil", key);
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        //Test生成对象
        Test *test = [[Test alloc] init];
        //通过KVC设值test的age
        [test setValue:nil forKey:@"age"];
        //通过KVC取值age打印
        NSLog(@"test的年龄是%@", [test valueForKey:@"age"]);
        //不能将age设成nil
        //test的年龄是0
    }
    return 0;
}

KVC处理UnderfinedKey异常

通常情况下，KVC不允许你要在调用setValue：属性值 forKey：(或者keyPath)时对不存在的key进行操作。
不然，会报错forUndefinedKey发生崩溃，重写forUndefinedKey方法避免崩溃。

#import 

@interface Test: NSObject {
}

@end

@implementation Test

- (id)valueForUndefinedKey:(NSString *)key {
    NSLog(@"出现异常，该key不存在%@",key);
    return nil;
}

- (void)setValue:(id)value forUndefinedKey:(NSString *)key {
    NSLog(@"出现异常，该key不存在%@", key);
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        //Test生成对象
        Test *test = [[Test alloc] init];
        //通过KVC设值test的age
        [test setValue:@10 forKey:@"age"];
        //通过KVC取值age打印
        NSLog(@"test的年龄是%@", [test valueForKey:@"age"]);
        
    }
    return 0;
}

打印结果：
出现异常，该key不存在age
出现异常，该key不存在age
test的年龄是(null)

KVC处理数值和结构体类型属性

不是每一个方法都返回对象，但是valueForKey：总是返回一个id对象，如果原本的变量类型是值类型或者结构体，返回值会封装成NSNumber或者NSValue对象。

这两个类会处理从数字，布尔值到指针和结构体任何类型。然后开以者需要手动转换成原来的类型。

尽管valueForKey：会自动将值类型封装成对象，但是setValue：forKey：却不行。你必须手动将值类型转换成NSNumber或者NSValue类型，才能传递过去。

因为传递进去和取出来的都是id类型，所以需要开发者自己担保类型的正确性，运行时Objective-C在发送消息的会检查类型，如果错误会直接抛出异常。

举个例子，Person类有个NSInteger类型的age属性，如下：

//  Person.m
#import "Person.h"
 
@interface Person ()
 
@property (nonatomic,assign) NSInteger age;
 
@end
 
 
@implementation Person
 
@end

修改值

我们通过KVC技术使用如下方式设置age属性的值：

[person setValue:[NSNumber numberWithInteger:5] forKey:@"age"];

我们赋给age的是一个NSNumber对象，KVC会自动的将NSNumber对象转换成NSInteger对象，然后再调用相应的访问器方法设置age的值。

获取值

同样，以如下方式获取age属性值：

[person valueForKey:@"age"];

这时，会以NSNumber的形式返回age的值。

//  ViewController.m
#import "ViewController.h"
#import "Person.h"

@interface ViewController ()

@end

@implementation ViewController


- (void)viewDidLoad {
    [super viewDidLoad];
    
    Person *person = [[Person alloc]init];
    [person setValue:[NSNumber numberWithInteger:5] forKey:@"age"];
    NSLog(@"age=%@",[person valueForKey:@"age"]);
    //age = 5 
}


@end

需要注意的是我们不能直接将一个数值通过KVC赋值的，我们需要把数据转为NSNumber和NSValue类型传入，那到底哪些类型数据要用NSNumber封装哪些类型数据要用NSValue封装呢？看下面这些方法的参数类型就知道了：

可以使用NSNumber的数据类型有：

+ (NSNumber*)numberWithChar:(char)value;
+ (NSNumber*)numberWithUnsignedChar:(unsignedchar)value;
+ (NSNumber*)numberWithShort:(short)value;
+ (NSNumber*)numberWithUnsignedShort:(unsignedshort)value;
+ (NSNumber*)numberWithInt:(int)value;
+ (NSNumber*)numberWithUnsignedInt:(unsignedint)value;
+ (NSNumber*)numberWithLong:(long)value;
+ (NSNumber*)numberWithUnsignedLong:(unsignedlong)value;
+ (NSNumber*)numberWithLongLong:(longlong)value;
+ (NSNumber*)numberWithUnsignedLongLong:(unsignedlonglong)value;
+ (NSNumber*)numberWithFloat:(float)value;
+ (NSNumber*)numberWithDouble:(double)value;
+ (NSNumber*)numberWithBool:(BOOL)value;
+ (NSNumber*)numberWithInteger:(NSInteger)valueNS_AVAILABLE(10_5,2_0);
+ (NSNumber*)numberWithUnsignedInteger:(NSUInteger)valueNS_AVAILABLE(10_5,2_0);

就是一些常见的数值型数据。

可以使用NSValue的数据类型有：

+ (NSValue*)valueWithCGPoint:(CGPoint)point;
+ (NSValue*)valueWithCGSize:(CGSize)size;
+ (NSValue*)valueWithCGRect:(CGRect)rect;
+ (NSValue*)valueWithCGAffineTransform:(CGAffineTransform)transform;
+ (NSValue*)valueWithUIEdgeInsets:(UIEdgeInsets)insets;
+ (NSValue*)valueWithUIOffset:(UIOffset)insetsNS_AVAILABLE_IOS(5_0);

NSValue主要用于处理结构体型的数据，它本身提供了如上集中结构的支持。任何结构体都是可以转化成NSValue对象的，包括其它自定义的结构体。

KVC键值验证（Key-Value-Validation）

KVC提供了验证Key对应的Value是否可用的方法：

- (BOOL)validateValue:(inoutid*)ioValue forKey:(NSString*)inKey error:(outNSError**)outError;

该方法默认的实现是调用一个如下格式的方法：

- (BOOL)validate<Key>:error:

例如：

#import 

@interface Test: NSObject {
    NSUInteger _age;
}

@end

@implementation Test

- (BOOL)validateValue:(inout id  _Nullable __autoreleasing *)ioValue forKey:(NSString *)inKey error:(out NSError * _Nullable __autoreleasing *)outError {
    NSNumber *age = *ioValue;
    if (age.integerValue == 10) {
        return NO;
    }
    
    return YES;
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        //Test生成对象
        Test *test = [[Test alloc] init];
        //通过KVC设值test的age
        NSNumber *age = @10;
        NSError* error;
        NSString *key = @"age";
        BOOL isValid = [test validateValue:&age forKey:key error:&error];
        if (isValid) {
            NSLog(@"键值匹配");
            [test setValue:age forKey:key];
        }
        else {
            NSLog(@"键值不匹配");
        }
        //通过KVC取值age打印
        NSLog(@"test的年龄是%@", [test valueForKey:@"age"]);
        
        //键值不匹配
        //test的年龄是0
    }
    return 0;
}

这样就给了我们一次纠错的机会。需要指出的是，KVC是不会自动调用键值验证方法的，就是说我们如果想要键值验证则需要手动验证。但是有些技术，比如CoreData会自动调用。

KVC处理集合

KVC同时还提供了很复杂的函数，主要有下面这些：

简单集合运算符

简单集合运算符共有@avg ， @count ， @max ，@min ， @sum 5 种 ，表示的都是字面意识。看一个例子，目前不支持自定义。

#import 

@interface Book : NSObject
@property (nonatomic, copy)  NSString* name;
@property (nonatomic, assign)  CGFloat price;
@end

@implementation Book
@end


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        Book *book1 = [Book new];
        book1.name = @"The Great Gastby";
        book1.price = 10;
        Book *book2 = [Book new];
        book2.name = @"Time History";
        book2.price = 20;
        Book *book3 = [Book new];
        book3.name = @"Wrong Hole";
        book3.price = 30;
        
        Book *book4 = [Book new];
        book4.name = @"Wrong Hole";
        book4.price = 40;
        
        NSArray* arrBooks = @[book1,book2,book3,book4];
        NSNumber* sum = [arrBooks valueForKeyPath:@"@sum.price"];
        NSLog(@"sum:%f",sum.floatValue);
        NSNumber* avg = [arrBooks valueForKeyPath:@"@avg.price"];
        NSLog(@"avg:%f",avg.floatValue);
        NSNumber* count = [arrBooks valueForKeyPath:@"@count"];
        NSLog(@"count:%f",count.floatValue);
        NSNumber* min = [arrBooks valueForKeyPath:@"@min.price"];
        NSLog(@"min:%f",min.floatValue);
        NSNumber* max = [arrBooks valueForKeyPath:@"@max.price"];
        NSLog(@"max:%f",max.floatValue);
        
    }
    return 0;
}

打印结果：
sum:100.000000
avg:25.000000
count:4.000000
min:10.000000
max:40.000000

对象运算符

比集合运算符稍微复杂，能以数组的方式返回指定的内容，一共有两种：

• @distinctUnionOfObjects
• @unionOfObjects

它们的返回值都是NSArray，区别是前者返回的元素都是唯一的，是去重以后的结果；后者返回的元素是全集。

例如：

#import 

@interface Book : NSObject
@property (nonatomic, copy)  NSString* name;
@property (nonatomic, assign)  CGFloat price;
@end

@implementation Book
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        Book *book1 = [Book new];
        book1.name = @"The Great Gastby";
        book1.price = 40;
        Book *book2 = [Book new];
        book2.name = @"Time History";
        book2.price = 20;
        Book *book3 = [Book new];
        book3.name = @"Wrong Hole";
        book3.price = 30;
        
        Book *book4 = [Book new];
        book4.name = @"Wrong Hole";
        book4.price = 10;
        
        NSArray* arrBooks = @[book1,book2,book3,book4];
        
        NSLog(@"distinctUnionOfObjects");
        NSArray* arrDistinct = [arrBooks valueForKeyPath:@"@distinctUnionOfObjects.price"];
        for (NSNumber *price in arrDistinct) {
            NSLog(@"%f",price.floatValue);
        }
        NSLog(@"unionOfObjects");
        NSArray* arrUnion = [arrBooks valueForKeyPath:@"@unionOfObjects.price"];
        for (NSNumber *price in arrUnion) {
            NSLog(@"%f",price.floatValue);
        }
        
    }
    return 0;
}

打印结果：
2018-05-05 17:06:21.832401+0800 KVCKVO[35798:6358293] distinctUnionOfObjects
10.000000
20.000000
30.000000
40.000000
unionOfObjects
40.000000
20.000000
30.000000
10.000000

KVC处理字典

当对NSDictionary对象使用KVC时，valueForKey：的表现行为和objectForkey：一样。所以使用valueForKeyPath:用来访问多层嵌套的字典是比较方便的。

KVC里面还有两个关于NSDictionary的方法:

- (NSDictionary<NSString *, id> *)dictionaryWithValuesForKeys:(NSArray<NSString *> *)keys;
//输入一组key，返回这组key对应的属性，再组成一个字典
- (void)setValuesForKeysWithDictionary:(NSDictionary<NSString *, id> *)keyedValues;
//用来修改Model中对应key的属性

下面直接用代码会更直观一点:

#import 

@interface Address : NSObject

@end

@interface Address()

@property (nonatomic, copy)NSString* country;
@property (nonatomic, copy)NSString* province;
@property (nonatomic, copy)NSString* city;
@property (nonatomic, copy)NSString* district;

@end

@implementation Address

@end


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        //模型转字典
        Address* add = [Address new];
        add.country = @"China";
        add.province = @"Guang Dong";
        add.city = @"Shen Zhen";
        add.district = @"Nan Shan";
        NSArray* arr = @[@"country",@"province",@"city",@"district"];
        NSDictionary* dict = [add dictionaryWithValuesForKeys:arr]; //把对应key所有的属性全部取出来
        NSLog(@"%@",dict);
        
        //字典转模型
        NSDictionary* modifyDict = @{@"country":@"USA",@"province":@"california",@"city":@"Los angle"};
        [add setValuesForKeysWithDictionary:modifyDict];            //用key Value来修改Model的属性
        NSLog(@"country:%@  province:%@ city:%@",add.country,add.province,add.city);
        
        
    }
    return 0;
}

打印结果：
{
city = "Shen Zhen";
country = China;
district = "Nan Shan";
province = "Guang Dong";
}
country:USA province:california city:Los angle

KVC使用

下面列举iOS开发中KVC的使用场景.

动态地取值和设值

利用KVC动态的取值和设值是最基本的用途了。

用KVC来访问和修改私有变量

对于类里的私有属性，Objective-C是无法直接访问的，但是KVC是可以的。

Model和字典转换

这是KVC强大作用的又一次体现，KVC和Objc的runtime组合可以很容易的实现Model和字典的转换。

修改一些控件的内部属性

这也是iOS开发中必不可少的小技巧。众所周知很多UI控件都由很多内部UI控件组合而成的，但是Apple度没有提供这访问这些控件的API，这样我们就无法正常地访问和修改这些控件的样式。
而KVC在大多数情况可下可以解决这个问题。最常用的就是个性化UITextField中的placeHolderText了。

操作集合

Apple对KVC的valueForKey:方法作了一些特殊的实现，比如说NSArray和NSSet这样的容器类就实现了这些方法。所以可以用KVC很方便地操作集合。

用KVC实现高阶消息传递

当对容器类使用KVC时，valueForKey:将会被传递给容器中的每一个对象，而不是容器本身进行操作。结果会被添加进返回的容器中，这样，开发者可以很方便的操作集合来返回另一个集合。

#import 

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        NSArray* arrStr = @[@"english",@"franch",@"chinese"];
        NSArray* arrCapStr = [arrStr valueForKey:@"capitalizedString"];
        for (NSString* str  in arrCapStr) {
            NSLog(@"%@",str);
        }
        NSArray* arrCapStrLength = [arrStr valueForKeyPath:@"capitalizedString.length"];
        for (NSNumber* length  in arrCapStrLength) {
            NSLog(@"%ld",(long)length.integerValue);
        }
        
    }
    return 0;
}

打印结果：
English
Franch
Chinese
7
6
7

方法capitalizedString被传递到NSArray中的每一项，这样，NSArray的每一员都会执行capitalizedString并返回一个包含结果的新的NSArray。
从打印结果可以看出，所有String都成功以转成了大写。
同样如果要执行多个方法也可以用valueForKeyPath:方法。它先会对每一个成员调用 capitalizedString方法，然后再调用length，因为lenth方法返回是一个数字，所以返回结果以NSNumber的形式保存在新数组里。

KVO

面试问题：

• iOS用什么方式实现对一个对象的KVO？

• 如何手动触发KVO？

KVO简介

KVO就是键值观测。有时候有这种需求，就是需要知道一个对象的属性的任何变化来改变做出相应的响应，这时候就可以使用KVO。
KVO中有两个关键的方法。

• 添加观测者

   /***************
     @observer:就是观察者，是谁想要观测对象的值的改变。
     @keyPath:就是想要观察的对象属性。
     @options:options一般选择NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld，这样当属性值发生改变时我们可以同时获得旧值和新值，如果我们只填NSKeyValueObservingOptionNew则属性发生改变时只会获得新值。
     @context:想要携带的其他信息，比如一个字符串或者字典什么的。
     **************/
    - (void)addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(nullable void *)context;

option所包含的

NSKeyValueObservingOptionNew：change字典包括改变后的值
NSKeyValueObservingOptionOld:change字典包括改变前的值
NSKeyValueObservingOptionInitial:注册后立刻触发KVO通知
NSKeyValueObservingOptionPrior:值改变前是否也要通知（这个key决定了是否在改变前改变后通知两次）

• 当所观测的属性值发生改变时调用的函数

    /********************
     @keyPath:观察的属性
     @object:观察的是哪个对象的属性
     @change:这是一个字典类型的值，通过键值对显示新的属性值和旧的属性值
     @context:上面添加观察者时携带的信息
     *******************/
    - (void)observeValueForKeyPath:(nullable NSString *)keyPath ofObject:(nullable id)object change:(nullable NSDictionary<NSKeyValueChangeKey, id> *)change context:(nullable void *)context;

举例：

@interface ViewController ()

@property (nonatomic, strong)Person *person;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.person = [[Person alloc] init];
    self.person.age = 5;
    NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
    [self.person addObserver:self forKeyPath:@"age" options:options context:@"测试信息"];
    
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    
    self.person.age = 10;
}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context{
    
    NSLog(@"被观测对象：%@, 被观测的属性：%@, 值的改变: %@\n, 携带信息:%@", object, keyPath, change, context);
}

打印结果
 被观测对象：
 被观测的属性：age
 值的改变: {
    kind = 1;
    new = 10;
    old = 5;
}
 携带信息:测试信息

KVO本质分析

我们创建两个Person对象person1和person2，监听person1的age属性而不监听person2，触摸屏幕的时候同时改变person1和person2的age属性。

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.person1 = [[Person alloc] init];
    self.person1.age = 5;
    self.person2 = [[Person alloc] init];
    self.person2.age = 6;
    NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld;
    [self.person1 addObserver:self forKeyPath:@"age" options:options context:@"测试信息"];
    
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    
    self.person1.age = 10;
    self.person2.age = 11;
}

触摸屏幕之后通过打印值发现只能监听到person1对象的age属性值发生了改变，而不能监听person2。这个也很好理解，因为我们没有监听person2的属性。但是我们想一下

self.person1.age = 10;
self.person2.age = 11;

就是调用了Person类的set方法：

[self.person1 setAge:10];
[self.person2 setAge:11];

同样是调用set方法，为什么加了观察者效果就不一样呢？
问题就出自对象本身。
我们打断点打印一下person1和person2的isa，看看isa是什么。

通过这个打印的结果我们可以清晰的看到，person1的isa指针竟然指向NSKVONotifying_Person这个陌生的类，而person2的isa指针则是正常的指向Person类。我们知道实例对象的isa指针指向的是类对象，所以正常而言person1的isa指针指向的是Person类对象，由于加了观测者，导致其isa指向了NSKVONotifying_Person。

我们看一下person2的结构：

为了弄清person1的结构，我们打印看一下NSKVONotifying_Person的类对象的superclass指针指向哪里：

这个打印结果就说明NSKVONotifying_Person这个类是Person类的子类。据此我们猜测出person1对象的结构图：

接下来我们可以写一下这个NSKVONotifying_Person这个类的伪代码：

@implementation NSKVONotifying_Person

- (void)setAge:(int)age{
    
    _NSSetIntValueAndNotify();
}

void __NSSetIntValueAndNotify()
{
    
    [self willChangeValueForKey:@"age"];
    [super setAge:age];
    [self didChangeValueForKey:@"age"];
}

- (void)didChangeValueForKey:(NSString *)key{
    
    [observer observeValueForKeyPath:key ofObject:self change:nil context:nil];
}

@end

在NSKVONotifying_Person这个子类的setAge:方法中主要是实现了一个C方法_NSSetIntValueAndNotify(),这个方法的实现分三步，首先是属性将要改变时调用willChangeValueForKey:，然后是调用父类即Person类的setAge:方法来真正的改变age属性的值，当age属性的值改变完成之后再调用didChangeValueForKey:这个方法来通知监听者属性值已经改变。

验证

• 打印类对象 在person1添加监听者之后我们打印一下person1和person2对应的类对象：

NSLog(@"person1添加KVO监听之后：-%@ %@", object_getClass(self.person1), object_getClass(self.person2));

结果：

person1添加KVO监听之后：-NSKVONotifying_Person Person

• 查看添加监听前后setAge:方法的实现
• (IMP)methodForSelector:(SEL)aSelector;这个方法是传入一个selector返回一个方法的实现即imp，这里我们打印一下person1添加监听前后person1和person2的setAge:方法的实现的地址来判断这两个对象调用的的setAge:方法是否发生了改变：

NSLog(@"person1添加监听之前：- %p %p", [self.person1 methodForSelector:@selector(setAge:)], [self.person2 methodForSelector:@selector(setAge:)]);
    
[self.person1 addObserver:self forKeyPath:@"age" options:options context:@"测试信息"];
    
NSLog(@"person1添加监听之后：- %p %p", [self.person1 methodForSelector:@selector(setAge:)], [self.person2 methodForSelector:@selector(setAge:)]);

打印结果：

person1添加监听之前：- 0x10f5c84d0 0x10f5c84d0
person1添加监听之后：- 0x10f96df8e 0x10f5c84d0

可以看到person1添加监听前后person1的setAge:方法发生了变化，添加监听前它是调用的Person类的setAge:方法，添加监听后变成了调用_NSSetIntValueAndNotify这样一个C函数。

KVO内部调用顺序

KVO内部调用顺序也就是_NSSetIntValueAndNotify这样一个C函数的执行过程。前面的伪代码写过这个C函数的执行过程大概分三步：

[self willChangeValueForKey:@"age"];
[super setAge:age];
[self didChangeValueForKey:@"age"];

由于我们无法去窥探_NSSetIntValueAndNotify的真实结构，也无法去重写NSKVONotifying_Person这个类，所以我们只能利用它的父类Person类来分析其执行过程。
在Person类里面重写willChangeValueForKey:和didChangeValueForKey:这两个方法，但是只是简单的调用父类的方法，除此之外不做其他的有效处理，这样不会影响其执行。

@implementation Person

- (void)setAge:(int)age{
    
    _age = age;
    
    NSLog(@"setAge:");
}

- (void)willChangeValueForKey:(NSString *)key{
    
    [super willChangeValueForKey:key];
    
    NSLog(@"willChangeValueForKey");
}

- (void)didChangeValueForKey:(NSString *)key{
    
    NSLog(@"didChangeValueForKey - begin");
    
    [super didChangeValueForKey:key];
    
    NSLog(@"didChangeValueForKey - end");
}

@end

看一下结果：

通过这个图我们可以看到：

1.首先调用willChangeValueForKey:方法。
2.然后调用setAge:方法真正的改变属性的值。
3.开始调用didChangeValueForKey:这个方法，调用[super didChangeValueForKey:key]时会通知监听者属性值已经改变，然后监听者执行自己的- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context这个方法。

NSKVONotifying_Person这个类的内部方法

在上面贴出的图中NSKVONotifying_Person这个类的结构是这样的：

这个图里面有一些我们很熟悉，比如这个isa，superclass，setAge:这些方法。而-dealloc则是主要做一些收尾工作，比如移除监听器等等。那么这个class方法主要是干什么的呢？
首先我们通过两种方式来打印一下person1和person2的类对象，一种是使用runtime的object_getClass()方法，另外一种是直接调用实例对象的class方法：

NSLog(@"%@ %@", object_getClass(self.person1), object_getClass(self.person2));
NSLog(@"%@ %@", [self.person1 class], [self.person2 class]);

结果：

NSKVONotifying_Person Person
Person Person

奇怪了，为什么使用两种方式的打印结果不一样呢？通过前面的分析我们已经知道了，person1对象的类对象是 ，我们通过runtime打印出来的是NSKVONotifying_Person对的，但是通过[self.person1 class]这种方式打印出来的结果是错误的。原因就是NSKVONotifying_Person这个类重写了class方法，很可能就是直接返回了[Person class]

- (Class)class{
    
    return [Person class];
}

为什么要重写class这个方法呢？

苹果并不希望把NSKVONotifying_Person这个类暴露出来，屏蔽内部实现，隐藏这个类的存在。

打印NSKVONotifying_Person这个类的方法名

前面提到NSKVONotifying_Person这个类中有isa,superclass,setAge:,dealloc,class这些方法都还只是我们的猜想，俺么怎么证明这个类中有这些方法呢？我们使用runtime打印NSKVONotifying_Person这个类中的方法名。

- (void)printClassMethodNamesOfClass:(Class)cls{
    
    unsigned int count;
    //获得方法数组
    Method *methodList = class_copyMethodList(cls, &count);
    //遍历所有的方法
    for(int i = 0; i < count; i++){
        
        //获得方法
        Method method = methodList[i];
        //获得方法名
        NSString *methodName = NSStringFromSelector(method_getName(method));
        NSLog(@"方法名：%@ \n", methodName);
    }
    
    free(methodList);
}

我们写这个函数，通过传入一个类对象来打印这个类的所有函数名。
调用：

[self printClassMethodNamesOfClass:object_getClass(self.person1)];

查看结果：

2018-07-08 16:56:12.115606+0800 interview-KVO[4433:314695] setAge:
2018-07-08 16:56:12.115719+0800 interview-KVO[4433:314695] setAge:
2018-07-08 16:56:12.116083+0800 interview-KVO[4433:314695] 方法名：setAge: 

2018-07-08 16:56:12.116178+0800 interview-KVO[4433:314695] 方法名：class 

2018-07-08 16:56:12.116259+0800 interview-KVO[4433:314695] 方法名：dealloc 

2018-07-08 16:56:12.116349+0800 interview-KVO[4433:314695] 方法名：_isKVOA 

通过打印结果也就验证了我们的猜测。

直接修改成员变量会触发KVO吗？

不会，KVO的本质是set方法，只有调用了set方法才会触发KVO。

如何手动触发KVO

手动调用willChangeValueForKey和didChangeValueForKey方法。

后记

本文主要用作笔记记录，对前辈们的分享进行整理。
附上链接
IOS KVC和KVO详解
KVO的本质
相信你在看完本文后，也会对消息通知机制与KVO有什么区别感到疑惑，这里发现一篇不错的文章供大家食用
华山论剑之NSNotification(通知)与KVO(观察者模式)