iOS KVC和KVO詳解

KVC

KVC定義

KVC（Key-value coding）鍵值編碼，就是指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>方法的話，會按照_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  -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>://可選的，如果在此類操作上有效能問題，就需要考慮實現之
複製程式碼

無序集合對應方法如下：

-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設值

KVC要設值，那麼就要物件中對應的key，KVC在內部是按什麼樣的順序來尋找key的。當呼叫setValue：屬性值 forKey：@”name“的程式碼時，底層的執行機制如下：

• 程式優先呼叫set:屬性值方法，程式碼通過setter方法完成設定。注意，這裡的是指成員變數名，首字母大小寫要符合KVC的命名規則，下同

• 如果沒有找到setName：方法，KVC機制會檢查+ (BOOL)accessInstanceVariablesDirectly方法有沒有返回YES，預設該方法會返回YES，如果你重寫了該方法讓其返回NO的話，那麼在這一步KVC會執行setValue：forUndefinedKey：方法，不過一般開發者不會這麼做。所以KVC機制會搜尋該類裡面有沒有名為_的成員變數，無論該變數是在類介面處定義，還是在類實現處定義，也無論用了什麼樣的訪問修飾符，只在存在以_命名的變數，KVC都可以對該成員變數賦值。

• 如果該類即沒有set：方法，也沒有_成員變數，KVC機制會搜尋_is的成員變數。

• 和上面一樣，如果該類即沒有set：方法，也沒有_和_is成員變數，KVC機制再會繼續搜尋和is的成員變數。再給它們賦值。

• 如果上面列出的方法或者成員變數都不存在，系統將會執行該物件的setValue：forUndefinedKey：方法，預設是丟擲異常。

簡單來說就是如果沒有找到Set<Key>方法的話，會按照_key，_iskey，key，iskey的順序搜尋成員並進行賦值操作。

如果開發者想讓這個類禁用KVC裡，那麼重寫+ (BOOL)accessInstanceVariablesDirectly方法讓其返回NO即可，這樣的話如果KVC沒有找到set:屬性名時，會直接用setValue：forUndefinedKey：方法。

下面看例子：

#import <Foundation/Foundation.h>

@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"]);
        
    }
    return 0;
}
複製程式碼

列印結果： 2018-05-05 15:36:52.354405+0800 KVCKVO[35231:6116188] obj的名字是xiaoming

可以看到通過- (void)setValue:(nullable id)value forKey:(NSString *)key;和- (nullable id)valueForKey:(NSString *)key;成功設定和取出obj物件的name值。

再看一下設定accessInstanceVariablesDirectly為NO的效果：

#import <Foundation/Foundation.h>

@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;
}
複製程式碼

列印結果: 2018-05-05 15:45:22.399021+0800 KVCKVO[35290:6145826] 出現異常，該key不存在name 2018-05-05 15:45:22.399546+0800 KVCKVO[35290:6145826] 出現異常，該key不存在name 2018-05-05 15:45:22.399577+0800 KVCKVO[35290:6145826] obj的名字是(null)

可以看到accessInstanceVariablesDirectly為NO的時候KVC只會查詢setter和getter這一層，下面尋找key的相關變數執行就會停止，直接報錯。

設定accessInstanceVariablesDirectly為YES，再修改_name為_isName，看看執行是否成功。

#import <Foundation/Foundation.h>

@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;
}
複製程式碼

列印結果： 2018-05-05 15:49:53.444350+0800 KVCKVO[35303:6157671] obj的名字是xiaoming

從列印可以看到設定accessInstanceVariablesDirectly為YES，KVC會繼續按照順序查詢，併成功設值和取值了。

KVC取值

當呼叫valueForKey：@”name“的程式碼時，KVC對key的搜尋方式不同於setValue：屬性值 forKey：@”name“，其搜尋方式如下：

• 首先按get,,is的順序方法查詢getter方法，找到的話會直接呼叫。如果是BOOL或者Int等值型別， 會將其包裝成一個NSNumber物件。

• 如果上面的getter沒有找到，KVC則會查詢countOf,objectInAtIndex或AtIndexes格式的方法。如果countOf方法和另外兩個方法中的一個被找到，那麼就會返回一個可以響應NSArray所有方法的代理集合(它是NSKeyValueArray，是NSArray的子類)，呼叫這個代理集合的方法，或者說給這個代理集合傳送屬於NSArray的方法，就會以countOf,objectInAtIndex或AtIndexes這幾個方法組合的形式呼叫。還有一個可選的get:range:方法。所以你想重新定義KVC的一些功能，你可以新增這些方法，需要注意的是你的方法名要符合KVC的標準命名方法，包括方法簽名。

• 如果上面的方法沒有找到，那麼會同時查詢countOf，enumeratorOf,memberOf格式的方法。如果這三個方法都找到，那麼就返回一個可以響應NSSet所的方法的代理集合，和上面一樣，給這個代理集合發NSSet的訊息，就會以countOf，enumeratorOf,memberOf組合的形式呼叫。

• 如果還沒有找到，再檢查類方法+ (BOOL)accessInstanceVariablesDirectly,如果返回YES(預設行為)，那麼和先前的設值一樣，會按_,_is,,is的順序搜尋成員變數名，這裡不推薦這麼做，因為這樣直接訪問例項變數破壞了封裝性，使程式碼更脆弱。如果重寫了類方法+ (BOOL)accessInstanceVariablesDirectly返回NO的話，那麼會直接呼叫valueForUndefinedKey:方法，預設是丟擲異常。

給Test類新增getAge方法，例如如下:

#import <Foundation/Foundation.h>

@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"]);
        
    }
    return 0;
}
複製程式碼

列印結果： 2018-05-05 16:00:04.207857+0800 KVCKVO[35324:6188613] obj的年齡是10

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

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

#import <Foundation/Foundation.h>

@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"]);
        
    }
    return 0;
}
複製程式碼

列印結果： 2018-05-05 16:02:27.270954+0800 KVCKVO[35337:6195086] obj的年齡是10

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

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

#import <Foundation/Foundation.h>

@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"]);
        
    }
    return 0;
}
複製程式碼

列印結果： 2018-05-05 16:03:56.234338+0800 KVCKVO[35345:6201242] obj的年齡是10

可以看到[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 <Foundation/Foundation.h>

@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"]);
        
    }
    return 0;
}
複製程式碼

列印結果： 2018-05-05 16:19:02.613394+0800 KVCKVO[35436:6239788] test的"test1的name"是xiaoming

從列印結果來看我們成功的通過keyPath設定了test1的值。 KVC對於keyPath是搜尋機制第一步就是分離key，用小數點.來分割key，然後再像普通key一樣按照先前介紹的順序搜尋下去。

KVC處理異常

KVC中最常見的異常就是不小心使用了錯誤的key，或者在設值中不小心傳遞了nil的值，KVC中有專門的方法來處理這些異常。

KVC處理nil異常

通常情況下，KVC不允許你要在呼叫setValue：屬性值 forKey：(或者keyPath)時對非物件傳遞一個nil的值。很簡單，因為值型別是不能為nil的。如果你不小心傳了，KVC會呼叫setNilValueForKey:方法。這個方法預設是丟擲異常，所以一般而言最好還是重寫這個方法。

程式碼實現如下：

#import <Foundation/Foundation.h>

@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"]);
        
    }
    return 0;
}
複製程式碼

列印結果： 2018-05-05 16:24:30.302134+0800 KVCKVO[35470:6258307] 不能將age設成nil 2018-05-05 16:24:30.302738+0800 KVCKVO[35470:6258307] test的年齡是0

KVC處理UndefinedKey異常

通常情況下，KVC不允許你要在呼叫setValue：屬性值 forKey：(或者keyPath)時對不存在的key進行操作。 不然，會報錯forUndefinedKey發生崩潰，重寫forUndefinedKey方法避免崩潰。

#import <Foundation/Foundation.h>

@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;
}
複製程式碼

列印結果： 2018-05-05 16:30:18.564680+0800 KVCKVO[35487:6277523] 出現異常，該key不存在age 2018-05-05 16:30:18.565190+0800 KVCKVO[35487:6277523] 出現異常，該key不存在age 2018-05-05 16:30:18.565216+0800 KVCKVO[35487:6277523] 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"]);
    
}


@end
複製程式碼

列印結果： 2017-01-16 16:31:55.709 Test[28586:2294177] age=5

需要注意的是我們不能直接將一個數值通過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 <Foundation/Foundation.h>

@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"]);
        
    }
    return 0;
}
複製程式碼

列印結果： 2018-05-05 16:59:06.111671+0800 KVCKVO[35777:6329982] 鍵值不匹配 2018-05-05 16:59:06.112215+0800 KVCKVO[35777:6329982] test的年齡是0

這樣就給了我們一次糾錯的機會。需要指出的是，KVC是不會自動呼叫鍵值驗證方法的，就是說我們如果想要鍵值驗證則需要手動驗證。但是有些技術，比如CoreData會自動呼叫。

KVC處理集合

KVC同時還提供了很複雜的函式，主要有下面這些：

簡單集合運算子

簡單集合運算子共有@avg， @count ， @max ， @min ，@sum5種，都表示什麼直接看下面例子就明白了， 目前還不支援自定義。

#import <Foundation/Foundation.h>

@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;
}
複製程式碼

列印結果： 2018-05-05 17:04:50.674243+0800 KVCKVO[35785:6351239] sum:100.000000 2018-05-05 17:04:50.675007+0800 KVCKVO[35785:6351239] avg:25.000000 2018-05-05 17:04:50.675081+0800 KVCKVO[35785:6351239] count:4.000000 2018-05-05 17:04:50.675146+0800 KVCKVO[35785:6351239] min:10.000000 2018-05-05 17:04:50.675204+0800 KVCKVO[35785:6351239] max:40.000000

物件運算子

比集合運算子稍微複雜，能以陣列的方式返回指定的內容，一共有兩種：

• @distinctUnionOfObjects
• @unionOfObjects

它們的返回值都是NSArray，區別是前者返回的元素都是唯一的，是去重以後的結果；後者返回的元素是全集。

例如：

#import <Foundation/Foundation.h>

@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 2018-05-05 17:06:21.833079+0800 KVCKVO[35798:6358293] 10.000000 2018-05-05 17:06:21.833112+0800 KVCKVO[35798:6358293] 20.000000 2018-05-05 17:06:21.833130+0800 KVCKVO[35798:6358293] 30.000000 2018-05-05 17:06:21.833146+0800 KVCKVO[35798:6358293] 40.000000 2018-05-05 17:06:21.833165+0800 KVCKVO[35798:6358293] unionOfObjects 2018-05-05 17:06:21.833297+0800 KVCKVO[35798:6358293] 40.000000 2018-05-05 17:06:21.833347+0800 KVCKVO[35798:6358293] 20.000000 2018-05-05 17:06:21.833371+0800 KVCKVO[35798:6358293] 30.000000 2018-05-05 17:06:21.833388+0800 KVCKVO[35798:6358293] 10.000000

KVC處理字典

當對NSDictionary物件使用KVC時，valueForKey:的表現行為和objectForKey:一樣。所以使用valueForKeyPath:用來訪問多層巢狀的字典是比較方便的。

KVC裡面還有兩個關於NSDictionary的方法:

- (NSDictionary<NSString *, id> *)dictionaryWithValuesForKeys:(NSArray<NSString *> *)keys;
- (void)setValuesForKeysWithDictionary:(NSDictionary<NSString *, id> *)keyedValues;
複製程式碼

dictionaryWithValuesForKeys:是指輸入一組key，返回這組key對應的屬性，再組成一個字典。 setValuesForKeysWithDictionary是用來修改Model中對應key的屬性。下面直接用程式碼會更直觀一點:

#import <Foundation/Foundation.h>

@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;
}
複製程式碼

列印結果： 2018-05-05 17:08:48.824653+0800 KVCKVO[35807:6368235] { city = "Shen Zhen"; country = China; district = "Nan Shan"; province = "Guang Dong"; } 2018-05-05 17:08:48.825075+0800 KVCKVO[35807:6368235] country:USA province:california city:Los angle

列印出來的結果完全符合預期。

KVC使用

KVC在iOS開發中是絕不可少的利器，這種基於執行時的程式設計方式極大地提高了靈活性，簡化了程式碼，甚至實現很多難以想像的功能，KVC也是許多iOS開發黑魔法的基礎。 下面列舉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 <Foundation/Foundation.h>

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;
}
複製程式碼

列印結果： 2018-05-05 17:16:21.975983+0800 KVCKVO[35824:6395514] English 2018-05-05 17:16:21.976296+0800 KVCKVO[35824:6395514] Franch 2018-05-05 17:16:21.976312+0800 KVCKVO[35824:6395514] Chinese 2018-05-05 17:16:21.976508+0800 KVCKVO[35824:6395514] 7 2018-05-05 17:16:21.976533+0800 KVCKVO[35824:6395514] 6 2018-05-05 17:16:21.976550+0800 KVCKVO[35824:6395514] 7

方法capitalizedString被傳遞到NSArray中的每一項，這樣，NSArray的每一員都會執行capitalizedString並返回一個包含結果的新的NSArray。 從列印結果可以看出，所有String都成功以轉成了大寫。 同樣如果要執行多個方法也可以用valueForKeyPath:方法。它先會對每一個成員呼叫 capitalizedString方法，然後再呼叫length，因為lenth方法返回是一個數字，所以返回結果以NSNumber的形式儲存在新陣列裡。

實現KVO

KVO是基於KVC實現的，下面講一下KVO的概念和實現。

KVO

KVO定義

KVO 即 Key-Value Observing，翻譯成鍵值觀察。它是一種觀察者模式的衍生。其基本思想是，對目標物件的某屬性新增觀察，當該屬性發生變化時，通過觸發觀察者物件實現的KVO介面方法，來自動的通知觀察者。

觀察者模式是什麼 一個目標物件管理所有依賴於它的觀察者物件，並在它自身的狀態改變時主動通知觀察者物件。這個主動通知通常是通過呼叫各觀察者物件所提供的介面方法來實現的。觀察者模式較完美地將目標物件與觀察者物件解耦。

簡單來說KVO可以通過監聽key，來獲得value的變化，用來在物件之間監聽狀態變化。KVO的定義都是對NSObject的擴充套件來實現的，Objective-C中有個顯式的NSKeyValueObserving類別名，所以對於所有繼承了NSObject的型別，都能使用KVO(一些純Swift類和結構體是不支援KVC的，因為沒有繼承NSObject)。

KVO使用

註冊與解除註冊

如果我們已經有了包含可供鍵值觀察屬性的類，那麼就可以通過在該類的物件（被觀察物件）上呼叫名為 NSKeyValueObserverRegistration 的 category 方法將觀察者物件與被觀察者物件註冊與解除註冊：

- (void)addObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options context:(void *)context;
- (void)removeObserver:(NSObject *)observer forKeyPath:(NSString *)keyPath;
複製程式碼

observer:觀察者，也就是KVO通知的訂閱者。訂閱著必須實現 
observeValueForKeyPath:ofObject:change:context:方法
keyPath：描述將要觀察的屬性，相對於被觀察者。
options：KVO的一些屬性配置；有四個選項。
context: 上下文，這個會傳遞到訂閱著的函式中，用來區分訊息，所以應當是不同的。
複製程式碼

options所包括的內容

NSKeyValueObservingOptionNew：change字典包括改變後的值
NSKeyValueObservingOptionOld:change字典包括改變前的值
NSKeyValueObservingOptionInitial:註冊後立刻觸發KVO通知
NSKeyValueObservingOptionPrior:值改變前是否也要通知（這個key決定了是否在改變前改變後通知兩次）
複製程式碼

這兩個方法的定義在 Foundation/NSKeyValueObserving.h 中，NSObject，NSArray，NSSet均實現了以上方法，因此我們不僅可以觀察普通物件，還可以觀察陣列或結合類物件。在該標頭檔案中，我們還可以看到 NSObject 還實現了 NSKeyValueObserverNotification 的 category 方法（更多類似方法，請檢視該標頭檔案NSKeyValueObserving.h）：

- (void)willChangeValueForKey:(NSString *)key;
- (void)didChangeValueForKey:(NSString *)key;
複製程式碼

這兩個方法在手動實現鍵值觀察時會用到。注意在不用的時候，不要忘記解除註冊，否則會導致記憶體洩露。

處理變更通知

每當監聽的keyPath發生變化了，就會在這個函式中回撥。

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context
複製程式碼

在這裡，change 這個字典儲存了變更資訊，具體是哪些資訊取決於註冊時的 NSKeyValueObservingOptions。

手動KVO(禁用KVO)

KVO的實現，是對註冊的keyPath中自動實現了兩個函式，在setter中，自動呼叫。

- (void)willChangeValueForKey:(NSString *)key
- (void)didChangeValueForKey:(NSString *)key
複製程式碼

可能有時候，我們要實現手動的KVO，或者__我們實現的類庫不希望被KVO__。 這時候需要關閉自動生成KVO通知，然後手動的呼叫，手動通知的好處就是，可以靈活加上自己想要的判斷條件。下面看個例子如下：

@interface Target : NSObject
{
    int age;
}

// for manual KVO - age
- (int) age;
- (void) setAge:(int)theAge;

@end

@implementation Target

- (id) init
{
    self = [super init];
    if (nil != self)
    {
        age = 10;
    }
    
    return self;
}

// for manual KVO - age
- (int) age
{
    return age;
}

- (void) setAge:(int)theAge
{
    [self willChangeValueForKey:@"age"];
    age = theAge;
    [self didChangeValueForKey:@"age"];
}

+ (BOOL) automaticallyNotifiesObserversForKey:(NSString *)key {
    if ([key isEqualToString:@"age"]) {
        return NO;
    }

    return [super automaticallyNotifiesObserversForKey:key];
}

@end
複製程式碼

首先，需要手動實現屬性的 setter 方法，並在設定操作的前後分別呼叫 willChangeValueForKey: 和 didChangeValueForKey方法，這兩個方法用於通知系統該 key 的屬性值即將和已經變更了； 其次，要實現類方法 automaticallyNotifiesObserversForKey，並在其中設定對該 key 不自動傳送通知（返回 NO 即可）。這裡要注意，對其它非手動實現的 key，要轉交給 super 來處理。 如果需要__禁用該類KVO__的話直接automaticallyNotifiesObserversForKey返回NO，實現屬性的 setter 方法，不進行呼叫willChangeValueForKey: 和 didChangeValueForKey方法。

鍵值觀察依賴鍵

有時候一個屬性的值依賴於另一物件中的一個或多個屬性，如果這些屬性中任一屬性的值發生變更，被依賴的屬性值也應當為其變更進行標記。因此，object 引入了依賴鍵。

觀察依賴鍵

觀察依賴鍵的方式與前面描述的一樣，下面先在 Observer 的 observeValueForKeyPath:ofObject:change:context: 中新增處理變更通知的程式碼：

#import "TargetWrapper.h"

- (void) observeValueForKeyPath:(NSString *)keyPath
                       ofObject:(id)object 
                         change:(NSDictionary *)change
                        context:(void *)context
{
    if ([keyPath isEqualToString:@"age"])
    {
        Class classInfo = (Class)context;
        NSString * className = [NSString stringWithCString:object_getClassName(classInfo)
                                                  encoding:NSUTF8StringEncoding];
        NSLog(@" >> class: %@, Age changed", className);

        NSLog(@" old age is %@", [change objectForKey:@"old"]);
        NSLog(@" new age is %@", [change objectForKey:@"new"]);
    }
    else if ([keyPath isEqualToString:@"information"])
    {
        Class classInfo = (Class)context;
        NSString * className = [NSString stringWithCString:object_getClassName(classInfo)
                                                  encoding:NSUTF8StringEncoding];
        NSLog(@" >> class: %@, Information changed", className);
        NSLog(@" old information is %@", [change objectForKey:@"old"]);
        NSLog(@" new information is %@", [change objectForKey:@"new"]);
    }
    else
    {
        [super observeValueForKeyPath:keyPath
                             ofObject:object
                               change:change
                              context:context];
    }
}
複製程式碼

實現依賴鍵

在這裡，觀察的是 TargetWrapper 類的 information 屬性，該屬性是依賴於 Target 類的 age 和 grade 屬性。為此，我在 Target 中新增了 grade 屬性：

@interface Target : NSObject
@property (nonatomic, readwrite) int grade;
@property (nonatomic, readwrite) int age;
@end

@implementation Target
@synthesize age; // for automatic KVO - age
@synthesize grade;
@end
複製程式碼

下面來看看 TragetWrapper 中的依賴鍵屬性是如何實現的。

@class Target;

@interface TargetWrapper : NSObject
{
@private
    Target * _target;
}

@property(nonatomic, assign) NSString * information;
@property(nonatomic, retain) Target * target;

-(id) init:(Target *)aTarget;

@end

#import "TargetWrapper.h"
#import "Target.h"

@implementation TargetWrapper

@synthesize target = _target;

-(id) init:(Target *)aTarget
{
    self = [super init];
    if (nil != self) {
        _target = [aTarget retain];
    }
    
    return self;
}

-(void) dealloc
{
    self.target = nil;
    [super dealloc];
}

- (NSString *)information
{
    return [[[NSString alloc] initWithFormat:@"%d#%d", [_target grade], [_target age]] autorelease];
}

- (void)setInformation:(NSString *)theInformation
{
    NSArray * array = [theInformation componentsSeparatedByString:@"#"];
    [_target setGrade:[[array objectAtIndex:0] intValue]];
    [_target setAge:[[array objectAtIndex:1] intValue]];
}

+ (NSSet *)keyPathsForValuesAffectingInformation
{
    NSSet * keyPaths = [NSSet setWithObjects:@"target.age", @"target.grade", nil];
    return keyPaths;
}

//+ (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key
//{
//    NSSet * keyPaths = [super keyPathsForValuesAffectingValueForKey:key];
//    NSArray * moreKeyPaths = nil;
//    
//    if ([key isEqualToString:@"information"])
//    {
//        moreKeyPaths = [NSArray arrayWithObjects:@"target.age", @"target.grade", nil];
//    }
//    
//    if (moreKeyPaths)
//    {
//        keyPaths = [keyPaths setByAddingObjectsFromArray:moreKeyPaths];
//    }
//    
//    return keyPaths;
//}

@end
複製程式碼

首先，要手動實現屬性 information 的 setter/getter 方法，在其中使用 Target 的屬性來完成其 setter 和 getter。

其次，要實現 keyPathsForValuesAffectingInformation 或 keyPathsForValuesAffectingValueForKey: 方法來告訴系統 information 屬性依賴於哪些其他屬性，這兩個方法都返回一個key-path 的集合。在這裡要多說幾句，如果選擇實現 keyPathsForValuesAffectingValueForKey，要先獲取 super 返回的結果 set，然後判斷 key 是不是目標 key，如果是就將依賴屬性的 key-path 結合追加到 super 返回的結果 set 中，否則直接返回 super的結果。

在這裡，information 屬性依賴於 target 的 age 和 grade 屬性，target 的 age/grade 屬性任一發生變化，information 的觀察者都會得到通知。

Observer * observer = [[[Observer alloc] init] autorelease];
Target * target = [[[Target alloc] init] autorelease];

TargetWrapper * wrapper = [[[TargetWrapper alloc] init:target] autorelease];
[wrapper addObserver:observer
          forKeyPath:@"information"
             options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
             context:[TargetWrapper class]];

[target setAge:30];
[target setGrade:1];
[wrapper removeObserver:observer forKeyPath:@"information"];
複製程式碼

列印結果： class: TargetWrapper, Information changed old information is 0#10 new information is 0#30 class: TargetWrapper, Information changed old information is 0#30 new information is 1#30

KVO和執行緒

一個需要注意的地方是，KVO 行為是同步的，並且發生與所觀察的值發生變化的同樣的執行緒上。沒有佇列或者 Run-loop 的處理。手動或者自動呼叫 -didChange... 會觸發 KVO 通知。

所以，當我們試圖從其他執行緒改變屬性值的時候我們應當十分小心，除非能確定所有的觀察者都用執行緒安全的方法處理 KVO 通知。通常來說，我們不推薦把 KVO 和多執行緒混起來。如果我們要用多個佇列和執行緒，我們不應該在它們互相之間用 KVO。

KVO 是同步執行的這個特性非常強大，只要我們在單一執行緒上面執行（比如主佇列 main queue），KVO 會保證下列兩種情況的發生：

首先，如果我們呼叫一個支援 KVO 的 setter 方法，如下所示：

self.exchangeRate = 2.345;
複製程式碼

KVO 能保證所有 exchangeRate 的觀察者在 setter 方法返回前被通知到。

其次，如果某個鍵被觀察的時候附上了 NSKeyValueObservingOptionPrior 選項，直到 -observe... 被呼叫之前， exchangeRate 的 accessor 方法都會返回同樣的值。

KVO實現

KVO 是通過 isa-swizzling 實現的。 基本的流程就是編譯器自動為被觀察物件創造一個派生類，並將被觀察物件的isa 指向這個派生類。如果使用者註冊了對某此目標物件的某一個屬性的觀察，那麼此派生類會重寫這個方法，並在其中新增進行通知的程式碼。Objective-C 在傳送訊息的時候，會通過 isa 指標找到當前物件所屬的類物件。而類物件中儲存著當前物件的例項方法，因此在向此物件傳送訊息時候，實際上是傳送到了派生類物件的方法。由於編譯器對派生類的方法進行了 override，並新增了通知程式碼，因此會向註冊的物件傳送通知。注意派生類只重寫註冊了觀察者的屬性方法。

蘋果官方文件的說明如下：

Key-Value Observing Implementation Details

Automatic key-value observing is implemented using a technique called isa-swizzling.

The isa pointer, as the name suggests, points to the object's class which maintains a dispatch table. This dispatch table essentially contains pointers to the methods the class implements, among other data.

When an observer is registered for an attribute of an object the isa pointer of the observed object is modified, pointing to an intermediate class rather than at the true class. As a result the value of the isa pointer does not necessarily reflect the actual class of the instance.

You should never rely on the isa pointer to determine class membership. Instead, you should use the class method to determine the class of an object instance.

KVO的實現依賴於Runtime的強大動態能力。

即當一個型別為 ObjectA 的物件，被新增了觀察後，系統會生成一個 NSKVONotifying_ObjectA 類，並將物件的isa指標指向新的類，也就是說這個物件的型別發生了變化。這個類相比較於ObjectA，會重寫以下幾個方法。

重寫setter

在 setter 中，會新增以下兩個方法的呼叫。

- (void)willChangeValueForKey:(NSString *)key;
- (void)didChangeValueForKey:(NSString *)key;
複製程式碼

然後在 didChangeValueForKey: 中，去呼叫：

- (void)observeValueForKeyPath:(nullable NSString *)keyPath
                      ofObject:(nullable id)object
                        change:(nullable NSDictionary<NSKeyValueChangeKey, id> *)change
                       context:(nullable void *)context;
複製程式碼

包含了新值和舊值的通知。

於是實現了屬性值修改的通知。因為 KVO 的原理是修改 setter 方法，因此使用 KVO 必須呼叫 setter 。若直接訪問屬性物件則沒有效果。

重寫class

當修改了isa指向後，class的返回值不會變，但isa的值則發生改變。

#import <Foundation/Foundation.h>
#import <objc/runtime.h>

@interface ObjectA: NSObject

@property (nonatomic) NSInteger age;

@end

@implementation ObjectA
@end

@interface ObjectB: NSObject
@end

@implementation ObjectB

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    NSLog(@"%@", change);
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        
        //生成物件
        ObjectA *objA = [[ObjectA alloc] init];
        ObjectB *objB = [[ObjectB alloc] init];
        
        // 新增Observer之後
        [objA addObserver:objB forKeyPath:@"age" options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld context:nil];
        
        // 輸出ObjectA
        NSLog(@"%@", [objA class]);
        // 輸出NSKVONotifying_ObjectA（object_getClass方法返回isa指向）
        NSLog(@"%@", object_getClass(objA));

    }
    return 0;
}
複製程式碼

列印結果： 2018-05-06 22:47:05.538899+0800 KVCKVO[38474:13343992] ObjectA 2018-05-06 22:47:05.539242+0800 KVCKVO[38474:13343992] NSKVONotifying_ObjectA

重寫dealloc

系統重寫 dealloc 方法來釋放資源。

重寫_isKVOA

這個私有方法是用來標示該類是一個 KVO 機制聲稱的類。

如何證明被觀察的類被重寫了以上方法

參考用程式碼探討 KVC/KVO 的實現原理這篇文章，通過程式碼一步步分析，從斷點截圖來看，可以很好證明以上被重寫的方法。

關注我

歡迎關注公眾號：jackyshan，技術乾貨首發微信，第一時間推送。