本文為《招聘一個靠譜的 iOS》面試題的參考解答(上篇)。
說明:面試題出自微博 @我就叫Sunny怎麼了的博文《招聘一個靠譜的 iOS》,共 55 題,除第一題為風格糾錯題外,其餘 54 題皆為簡答題。
原文提供了高品質的題目但未附解答,因此我嘗試整理了一份答案,分兩篇發布。這是上篇,下篇將發布於此處,並會補完剩餘問題、進行勘誤,歡迎指正文中錯誤。答案未經出題者校對,如有疏漏請向微博 @iOS程序犭袁 指正。
出題者簡介:孫源(sunnyxx),任職於百度,負責百度知道 iOS 客戶端開發。他喜歡對技術刨根問底、歸納最佳實踐,熱愛分享與開源,並維護名為 forkingdog 的開源小組。

修改方式有很多種,以下提供一種示範:

下面把修改點分成兩部分說明:優化部分與硬傷部分。硬傷部分技術含量不高,為了節省時間放到後面講,可以先看優化部分。
1)枚舉建議使用 NS_ENUM 與 NS_OPTIONS 巨集定義,參見官方文件 Adopting Modern Objective-C:
//定義一個枚舉 typedef NS_ENUM(NSInteger, CYLSex) { CYLSexMan, CYLSexWoman };
2)age 屬性的型別:應避免直接使用基本型別,改用 Foundation 型別,對應關係如下:
int -> NSInteger unsigned -> NSUInteger float -> CGFloat 動畫時間 -> NSTimeInterval
同時考慮到年齡不會為負,應使用 NSUInteger 而非 int。這樣做是基於 64 位元適配的考量,細節可參考出題者的博文《64-bit Tips》。
3)前綴規範:專案龐大到需要拆分模組時,可在類別與 typedef 巨集命名上加前綴以避免衝突。
4)doLogIn 方法不該寫在這個類別裡:先不糾結 LogIn 的命名是否恰當(推測是 login 的意思),登入屬於業務邏輯。觀察類名 UserModel 與屬性命名方式,應該是採用 MVC 而非 MVVM,而 MVC 中業務邏輯不應寫在 Model 裡。(若是 MVVM,撇開命名規範不談,UserModel 這個類可能對應的是使用者註冊頁面;若有特殊業務需求,例如 login 實際對應的是「註冊並登入」的按鈕,出現 login 方法也可能是合理的。)
5)doLogIn 命名多餘:加了不必要的動詞前綴。請記住:如果方法表示讓物件執行一個動作,用動詞開頭命名即可,不要加上 do、does 這類冗詞,動詞本身就足夠清楚。
6)不要用 with 串接參數:-(id)initUserModelWithUserName: (NSString*)name withAge:(int)age; 中的 withAge: 應改為 age:,age: 已足以說明參數用途。也不建議用 andAge:——通常即使有類似 withA:withB: 的命名需求,也多寫成 withA:andB:,用來表示方法執行了兩個相對獨立的操作(從設計角度看,這種情況其實也該考慮拆成兩個方法),它並非用來闡明「有多個參數」:
//錯誤,不要使用"and"來連接參數 - (int)runModalForDirectory:(NSString *)path andFile:(NSString *)name andTypes:(NSArray *)fileTypes; //錯誤,不要使用"and"來闡明有多個參數 - (instancetype)initWithName:(CGFloat)width andAge:(CGFloat)height; //正確,使用"and"來表示兩個相對獨立的操作 - (BOOL)openFile:(NSString *)fullPath withApplication:(NSString *)appName andDeactivate:(BOOL)flag;
7)字串屬性應聲明為 copy:因為字串的值可能變動,內存管理語義需標明 copy。原因在後文有詳細論述。
8)性別屬性如何初始化?該類別只提供了一個初始化方法來設定姓名與年齡,那性別呢?
Objective-C 有 designated(指定)與 secondary(次要)初始化方法的概念。designated 初始化方法提供所有參數;secondary 初始化方法則透過提供一個或多個預設參數,去呼叫 designated 初始化方法。舉例:
// .m文件 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong // @implementation CYLUser - (instancetype)initWithName:(NSString *)name age:(int)age sex:(CYLSex)sex { if(self = [super init]) { _name = [name copy]; _age = age; _sex = sex; } return self; } - (instancetype)initWithName:(NSString *)name age:(int)age { return [self initWithName:name age:age sex:nil]; } @end
其中 initWithName:age:sex: 是 designated 初始化方法,另一個是 secondary 初始化方法,因為它僅是轉呼叫前者的實作。
由於出題者未提供 .m 檔,有兩種可能:一是原本只打算設計一個 designated 初始化方法,但漏掉了性別屬性,那麼就採用上面第一種改法;二是不打算在初始化時設定性別,預計後期再改,那麼應該把性別屬性設為 readwrite,改法如下:

在 .h 中公開 designated 初始化方法,是為了方便子類化(想深入了解可參考《禪與 Objective-C 編程藝術》中文版)。
9)搭配便捷構造方法:依介面設計慣例,設計了初始化方法就應搭配一個便捷構造方法,其回傳值建議為 instancetype。為保持一致,init 方法與便捷構造方法的回傳型別最好都用 instancetype。
10)屬性應盡量設為唯讀:若採用第一種改法,既然已透過初始化方法設定好姓名、年齡、性別,那對應的 @property 就應該盡量使用不可變物件,三個屬性都設為 readonly——初始化完成後便不能再改。本例中仍需標明內存管理語義,因此可改為:
@property (nonatomic, copy, readonly) NSString *name; @property (nonatomic, assign, readonly) NSUInter age; @property (nonatomic, assign, readonly) CYLSex sex;
由於是唯讀屬性,編譯器不會為它們建立 setter。即便如此,還是要標明這些屬性的語義,用以表明初始化方法設定這些值時所採用的方式。若不標明,呼叫者就不知道初始化方法會複製這些屬性,可能在呼叫前自行先複製一次,多餘且低效。
11)initUserModelWithUserName 改為 initWithName 更簡潔,且語意同樣清晰。
12)UserModel 改為 User 更簡潔,也足夠清楚。
13)UserSex 改為 Sex 更簡潔,也足夠清楚。
1)在 - 與 (void) 之間應有一個空格。
2)enum 中駝峰命名與底線命名混用。枚舉類型的命名規則與函數相同:使用駝峰命名法,勿用底線。
3)enum 左括號前加一個空格,或將左括號換到下一行。
4)enum 右括號後加一個空格。
5)UserModel :NSObject 應為 UserModel : NSObject,冒號右側少了一個空格。
6)@interface 與 @property 聲明之間應空一行。
7)兩個方法定義之間不需要空行;若為區分功能也可空一行,但範例中空了兩行。
8)-(id)initUserModelWithUserName: (NSString*)name withAge:(int)age; 中,方法名與參數之間多了空格,且 - 與 (id) 之間少了空格。
9)同一行中,(NSString*)name 前多了空格。
10)同一行中,(NSString*)name 應為 (NSString *)name,少了空格。
11)doLogIn 命名不清晰,推測是 login 的手誤。
12)第二個 @property 中 assign 與 nonatomic 順序應對調。
使用時機
1)在 ARC 中,可能出現循環參照時,通常讓其中一端使用 weak 來解決,例如 delegate 代理屬性。
2)自身已經對它有一次強參照,沒有必要再強參照一次,此時也會用 weak。自訂的 IBOutlet 控件屬性一般也使用 weak(當然也可以用 strong,下文有論述)。
差異
1)weak 表明該屬性定義了一種「非擁有關係」(nonowning relationship)。設定新值時,setter 既不保留新值也不釋放舊值。這點與 assign 類似,但差別在於:當屬性所指的物件被銷毀時,weak 屬性會自動清空為 nil;而 assign 的 setter 只做針對純量類型(例如 CGFloat、NSInteger)的簡單賦值。
2)assign 可以用於非 Objective-C 物件,weak 則必須用於 Objective-C 物件。
用途
1)NSString、NSArray、NSDictionary 等經常使用 copy,是因為它們都有對應的可變類型:NSMutableString、NSMutableArray、NSMutableDictionary。
2)block 也常用 copy,原因見官方文件 Objects Use Properties to Keep Track of Blocks。
block 使用 copy 是 MRC 時代留下的傳統:MRC 中方法內部的 block 位於堆疊區,用 copy 可以把它複製到堆區。在 ARC 下寫不寫都可以——對 block 而言 copy 與 strong 效果相同,但寫上 copy 無傷大雅,還能提醒自己編譯器自動執行了複製。

補充說明:copy 表達的擁有關係與 strong 類似,但 setter 不保留新值,而是將其複製一份。當屬性型別為 NSString 時,常用此特質保護封裝性,因為傳入的新值可能指向一個 NSMutableString 實例——它是 NSString 的子類,可修改內容。若不複製,設定完屬性後字串值可能在物件不知情的情況下被改掉。因此要複製一份不可變字串,確保值不會無意間變動。只要實作屬性所用的物件是可變的,就應該在設定新值時複製一份。
用 @property 聲明 NSString、NSArray、NSDictionary 時常用 copy,是因為它們有對應的可變類型,彼此之間可能發生賦值操作;為確保物件內的值不被外部改動,應在設定新值時複製。
兩個問題:
1、在增刪改陣列元素時,程式會因為找不到對應方法而崩潰——因為 copy 複製出來的是不可變的 NSArray 物件。
2、使用 atomic 屬性會嚴重影響效能。
第二點的原因:該屬性使用了同步鎖,會在編譯時產生額外套路以協助撰寫多執行緒程式,帶來效能負擔。宣告 nonatomic 可以省下這些雖小但不必要的開銷。
預設情況下,編譯器合成的方法會透過鎖定機制確保原子性(atomicity)。若屬性具備 nonatomic 特質,則不使用同步鎖。注意,並沒有一個叫 atomic 的特質關鍵字——不具備 nonatomic 的屬性就是「原子的」。
在 iOS 開發中你會發現,幾乎所有屬性都宣告為 nonatomic。一般並不要求屬性必須是原子的,因為這並不能保證執行緒安全;要實現執行緒安全,需要更深層的鎖定機制。舉例來說,若一個執行緒連續多次讀取某屬性值的過程中,另有執行緒在改寫它,那麼即使宣告為 atomic,仍可能讀到不同的值。因此 iOS 開發時一般都使用 nonatomic。而在開發 Mac OS X 程式時,使用 atomic 通常不會遇到效能瓶頸。
若想讓自訂物件具備複製能力,需實作 NSCopying 協議。若自訂物件分為可變與不可變版本,則需同時實作 NSCopying 與 NSMutableCopying 協議。
步驟:
1)宣告該類別遵循 NSCopying 協議
2)實作協議中唯一的方法:
- (id)copyWithZone: (NSZone*) zone
注意:一提到讓類別支援 copy,我們直覺想覆寫 copy 方法,但真正需要實作的其實是 copyWithZone:。
以第一題的程式碼為例:

然後實作協議方法:

但實務專案不會這麼單純。假設 CYLUser 裡還有一個陣列,用來存放與其他 CYLUser 物件建立或解除朋友關係的資料,那麼複製時就得把這個陣列也一併處理。所需程式碼如下:

// .m 檔


以上做法能滿足基本需求,但有缺陷:若需要深層複製,可考慮新增一個專門執行深拷貝的方法。
【註:深淺拷貝的概念見下文「用 @property 聲明的 NSString 經常使用 copy 關鍵字,為什麼?」】
範例中存放朋友物件的 set 是用 copyWithZone: 拷貝的,這種淺拷貝不會逐一複製 set 中的元素。若需要深拷貝,可以這樣寫一個專用的方法:
- (id)deepCopy { CYLUser *copy = [[[self copy] allocWithZone:zone] initWithName:_name age:_age sex:sex]; copy->_friends = [[NSMutableSet alloc] initWithSet:_friends copyItems:YES]; return copy; }
至於如何重寫帶 copy 的 setter,若撇開本例泛談,寫法如下:
- (void)setName:(NSString *)name { _name = [name copy]; }
但就上文的程式碼而言,我們不需要也不能重寫 name 的 setter:name 是唯讀屬性,編譯器不會為它建立 setter,透過初始化方法設定好之後便不能再改。(本例之所以仍標明 copy 語義,是為了讓呼叫者知道初始化方法會複製這些屬性,避免他們重複複製。)
那如何確保 name 被複製?在初始化方法中處理即可:
- (instancetype)initWithName:(NSString *)name age:(int)age sex:(CYLSex)sex { if(self = [super init]) { _name = [name copy]; _age = age; _sex = sex; _friends = [[NSMutableSet alloc] init]; } return self; }
本質
@property = ivar + getter + setter。
「屬性」有兩大概念:ivar(實例變數)與存取方法(access method = getter + setter)。
屬性作為 Objective-C 的一項特性,主要作用在於封裝物件中的資料。Objective-C 物件通常把所需資料存為各種實例變數,而實例變數一般透過存取方法存取:getter 讀取值,setter 寫入值。這個概念早已定型,並在 Objective-C 2.0 中透過「屬性」成為語言的一部分。正因為存取方法有著嚴格的命名規範,Objective-C 才能依名稱自動建立存取方法。因此也可以說:
@property = getter + setter;
例如這個類別:
@interface Person : NSObject @property NSString *firstName; @property NSString *lastName; @end
等效於:
@interface Person : NSObject - (NSString *)firstName; - (void)setFirstName:(NSString *)firstName; - (NSString *)lastName; - (void)setLastName:(NSString *)lastName; @end
自動合成(autosynthesis)
完成屬性定義後,編譯器會自動撰寫存取屬性所需的方法,這個過程稱為「自動合成」。它由編譯器在編譯期執行,所以編輯器裡看不到這些合成方法的原始碼。除了產生 getter、setter 之外,編譯器還會自動在類別中加入適當型別的實例變數,並在屬性名前加底線作為實例變數名。上例中會產生 _firstName 與 _lastName 兩個實例變數。也可以在實作檔中透過 @synthesize 指定實例變數名稱:
@implementation Person @synthesize firstName = _myFirstName; @synthesize lastName = myLastName; @end
我曾經反編譯相關程式碼以確認屬性的實作方式,大致會產生五樣東西:
1)OBJC_IVAR_$類名$屬性名稱:該屬性的「位移量」(offset),這個值是硬編碼的,表示該變數距離存放物件所在的記憶體起始位址有多遠。
2)setter 與 getter 方法對應的實作函數
3)ivar_list:成員變數列表
4)method_list:方法列表
5)prop_list:屬性列表
也就是說,每次新增一個屬性,系統都會在 ivar_list 加入成員變數描述、在 method_list 加入 setter 與 getter 的描述、在屬性列表加入屬性描述,然後計算該屬性在物件中的位移量,並產生 setter 與 getter 的實作:setter 從位移量位置開始賦值,getter 從該位置取值。為了讀取正確的位元組數,系統還會對位移量的指標型別做強制轉型。
1)在 protocol 中使用 property 只會產生 setter 與 getter 的方法宣告。我們使用屬性的目的,是希望遵循該協議的物件去實作它。
2)category 中使用 @property 同樣只會產生方法宣告。若真的需要為 category 加上屬性實作,得借助 runtime 的兩個函數:objc_setAssociatedObject 與 objc_getAssociatedObject。
先釐清 weak 的特性:weak 表明該屬性定義了一種「非擁有關係」。設定新值時,setter 既不保留新值也不釋放舊值。這點與 assign 類似,但差別在於物件被銷毀時屬性會自動清空為 nil。
那 runtime 如何實現 weak 變數的的自動置 nil?runtime 對已註冊的類別會進行布局,並把 weak 物件放進一個雜湊表中,以 weak 所指向的物件記憶體位址作為 key。當該物件引用計數歸零而 dealloc 時,runtime 便以此位址為鍵在 weak 表中搜尋,找出所有以它為鍵的 weak 物件,將它們設為 nil。
可以寫成這樣的偽程式碼:
objc_storeWeak(&a, b):把第二個參數(賦值物件 b)的記憶體位址作為 key,把第一個參數(weak 修飾的變數 a)的記憶體位址 &a 作為 value,註冊進 weak 表。若第二個參數為 0(nil),則把 &a 從 weak 表中移除。
你可以理解為 objc_storeWeak(value, key):當 key 變 nil,就把 value 置 nil。
在 b 非 nil 時,a 與 b 指向同一個記憶體位址;b 變 nil 時 a 也變 nil,此時向 a 發送訊息不會崩潰(Objective-C 中向 nil 發送訊息是安全的)。而如果 a 由 assign 修飾,b 變 nil 時 a 仍指向原位址,成為指標,此時向 a 發送訊息極易崩潰。
以下用偽程式碼模擬 runtime 的實作:
// 使用偽代碼模擬:runtime如何實現weak屬性 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong id obj1; objc_initWeak(&obj1, obj); /*obj引用計數變為0,變量作用域結束*/ objc_destroyWeak(&obj1);
整體作用:透過 objc_initWeak 初始化「附帶 weak 修飾符的變數(obj1)」,並在變數作用域結束時透過 objc_destroyWeak 釋放它。
內部實作分別如下:
objc_initWeak 會先把「附帶 weak 修飾符的變數」初始化為 0(nil),然後把賦值物件作為參數呼叫 objc_storeWeak:
obj1 = 0; obj_storeWeak(&obj1, obj);
也就是說:weak 修飾的指標預設值是 nil(在 Objective-C 中向 nil 發送訊息是安全的)。
接著 objc_destroyWeak 會把 0(nil)作為參數呼叫 objc_storeWeak:
objc_storeWeak(&obj1, 0);
前面那段程式碼因此等效於:
// 使用偽代碼模擬:runtime如何實現weak屬性 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong id obj1; obj1 = 0; objc_storeWeak(&obj1, obj); /* ... obj的引用計數變為0,被置nil ... */ objc_storeWeak(&obj1, 0);
偽程式碼只是為了方便理解,下面我們實際操作一次:如何讓沒有使用 weak 修飾的 @property 擁有 weak 的效果。可以從 setter 下手:
- (void)setObject:(NSObject *)object { objc_setAssociatedObject(self, "object", object, OBJC_ASSOCIATION_ASSIGN); [object cyl_runAtDealloc:^{ _object = nil; }]; }
兩個步驟:
1)在 setter 中設定關聯物件:
objc_setAssociatedObject(self, "object", object, OBJC_ASSOCIATION_ASSIGN);
2)在屬性所指物件被銷毀時清空屬性值。這一步同樣要借助 runtime:
//要銷毀的目標對象 id objectToBeDeallocated; //可以理解為一個“事件”:當上面的目標對象銷毀時,同時要發生的“事件”。 id objectWeWantToBeReleasedWhenThatHappens; objc_setAssociatedObject(objectToBeDeallocted, someUniqueKey, objectWeWantToBeReleasedWhenThatHappens, OBJC_ASSOCIATION_RETAIN);
思路清楚了就開始實作 cyl_runAtDealloc,分兩部分。
第一部分:建立一個類別,代表「目標物件銷毀時同時要發生的事件」,並借助 block 執行該事件。
// .h文件 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong // 這個類,可以理解為一個“事件”:當目標對象銷毀時,同時要發生的“事件”。借助block執行“事件”。 typedef void (^voidBlock)(void); @interface CYLBlockExecutor : NSObject - (id)initWithBlock:(voidBlock)block; @end // .m文件 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong // 這個類,可以理解為一個“事件”:當目標對象銷毀時,同時要發生的“事件”。借助block執行“事件”。 #import "CYLBlockExecutor.h" @interface CYLBlockExecutor() { voidBlock _block; } @implementation CYLBlockExecutor - (id)initWithBlock:(voidBlock)aBlock { self = [super init]; if (self) { _block = [aBlock copy]; } return self; } - (void)dealloc { _block ? _block() : nil; } @end
第二部分:核心程式碼,用 runtime 實作 cyl_runAtDealloc。
// CYLNSObject+RunAtDealloc.h文件 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong // 利用runtime實現cyl_runAtDealloc方法 #import "CYLBlockExecutor.h" const void *runAtDeallocBlockKey = &runAtDeallocBlockKey; @interface NSObject (CYLRunAtDealloc) - (void)cyl_runAtDealloc:(voidBlock)block; @end // CYLNSObject+RunAtDealloc.m文件 // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong // 利用runtime實現cyl_runAtDealloc方法 #import "CYLNSObject+RunAtDealloc.h" #import "CYLBlockExecutor.h" @implementation NSObject (CYLRunAtDealloc) - (void)cyl_runAtDealloc:(voidBlock)block { if (block) { CYLBlockExecutor *executor = [[CYLBlockExecutor alloc] initWithBlock:block]; objc_setAssociatedObject(self, runAtDeallocBlockKey, executor, OBJC_ASSOCIATION_RETAIN); } } @end
使用方式:先引入
#import "CYLNSObject+RunAtDealloc.h"
然後就能用了:
NSObject *foo = [[NSObject alloc] init]; [foo cyl_runAtDealloc:^{ NSLog(@"正在釋放foo!"); }];
有興趣深入理解原理的,可以參考博文 Fun With the Objective-C Runtime: Run Code at Deallocation of Any Object。
屬性可以擁有的特質分為四類:
原子性——nonatomic 特質。預設情況下編譯器合成的方法會透過鎖定機制確保原子性;具備 nonatomic 則不使用同步鎖。注意,雖然沒有名為 atomic 的特質,但寫在屬性特質中編譯器不會報錯。若自訂存取方法,就應遵循與屬性特質相符的原子性。
讀寫權限——readwrite(讀寫)、readonly(唯讀)
記憶體管理語義——assign、strong、weak、unsafe_unretained、copy
方法名稱——getter=<name>、setter=<name>
getter=<name> 的寫法:
@property (nonatomic, getter=isOn) BOOL on;
(setter=<name> 不常用也不推薦,故不在此列出。)
另有不常用的 nonnull、null_resettable、nullable。
不需要。在 ARC 環境下,無論強指標還是弱指標都無需在 dealloc 設為 nil,ARC 會自動處理。
即便編譯器不幫我們做,weak 也不需要手動置 nil——如前文所述,物件被銷毀時屬性值本身就會自動清空。
1)@property 有兩個對應關鍵字:@synthesize 與 @dynamic。兩者都不寫時,預設等同 @synthesize var = _var;
2)@synthesize 的語義是:若你沒有手動實作 setter 與 getter,編譯器會自動為你加上。
3)@dynamic 則告訴編譯器:屬性的 setter 與 getter 由使用者自行實作,不要自動產生(readonly 屬性只需提供 getter)。若宣告為 @dynamic var 卻未提供對應方法,編譯時不會報錯,但執行到 instance.var = someVar 時會因缺少 setter 而崩潰;執行到 someVar = var 時也會因缺少 getter 而崩潰。編譯期不檢查、執行期才查找方法,這就是所謂的動態綁定。
對應基本資料型別,預設為 atomic, readwrite, assign。
對於普通的 Objective-C 物件,預設為 atomic, readwrite, strong。
參考連結:
Objective-C ARC: strong vs retain and weak vs assign
Variable property attributes or Modifiers in iOS
1)因為父類指標可以指向子類物件。使用 copy 的目的是讓本物件的屬性不受外界影響——無論傳入的是可變還是不可變物件,自身持有的都是一個不可變副本。
2)若使用 strong,這個屬性就有可能指向一個可變物件;一旦該可變物件在外部被修改,就會連帶影響這個屬性。
copy 表達的擁有關係與 strong 類似,但 setter 不保留新值,而是複製一份。當屬性型別為 NSString 時,常用此特質保護封裝性,因為傳入的新值可能指向 NSMutableString 實例。若不複製,設定完屬性後字串值可能在物件不知情的情況下被改動。因此要複製一份不可變字串,確保值不會無意間變動。只要屬性實作用的物件是可變的,就應該在設定新值時複製。
要理解這件事,先要知道非集合類物件的 copy 行為:
對 immutable 物件做 copy 是指標複製(淺複製),mutableCopy 是內容複製;對 mutable 物件而言,copy 與 mutableCopy 都是內容複製。用程式碼表示:
[immutableObject copy] // 淺複製
[immutableObject mutableCopy] // 深複製
[mutableObject copy] // 深複製
[mutableObject mutableCopy] // 深複製
例如:
NSMutableString *string = [NSMutableString stringWithString:@"origin"];//copy NSString *stringCopy = [string copy];
查看記憶體會發現 string 與 stringCopy 的位址不同,說明此時做的是內容拷貝、深拷貝。即使接著執行:
[string appendString:@"origion!"]
stringCopy 的值也不會改變;但若不使用 copy,stringCopy 的值就會被改掉。集合類物件同理。
所以,用 @property 聲明 NSString、NSArray、NSDictionary 時常用 copy,是因為它們有對應的可變類型,彼此之間可能進行賦值操作;為確保物件內的值不被無意間改動,應在設定新值時複製一份。
參考連結:iOS 集合的深複製與淺複製
先說明一個概念:實例變數 = 成員變數 = ivar,這幾種說法指的是同一件事。
正如 Apple 官方文件 You Can Customize Synthesized Instance Variable Names 所述:

使用屬性時,編譯器會自動撰寫存取方法,這個過程叫「自動合成」。它由編譯器在編譯期執行,所以編輯器裡看不到這些合成方法的原始碼。除了產生方法,編譯器還會自動加入適當型別的實例變數,並在屬性名前加底線作為名稱。
@interface CYLPerson : NSObject @property NSString *firstName; @property NSString *lastName; @end
上例會產生 _firstName 與 _lastName 兩個實例變數。也可以在實作檔中透過 @synthesize 指定名稱:
@implementation CYLPerson @synthesize firstName = _myFirstName; @synthesize lastName = _myLastName; @end
這樣產生的實例變數就是 _myFirstName 與 _myLastName,不再使用預設名。一般無須修改預設名,但若你不喜歡用底線命名,可以用這個方式改成自己想要的名字。我仍推薦使用預設方案,因為大家都遵循同一套規則時,程式碼的可讀性最好。
總結 @synthesize 合成實例變數的規則:
1)若指定了成員變數名稱,會產生該名稱的成員變數。
2)若該成員變數已存在,就不再產生。
3)若是 @synthesize foo;,還會產生一個名為 foo 的成員變數——也就是說,未指定名稱時會自動產生與屬性同名的成員變數。
4)若是 @synthesize foo = _foo;,則不會產生名為 foo 的成員變數。
假如 property 名為 foo,且已存在名為 _foo 的實例變數,還會自動合成新變數嗎?不會。如下圖:

回答前先釐清:什麼情況下不會自動合成?
同時重寫了 setter 與 getter 時
重寫了唯讀屬性的 getter 時
使用了 @dynamic 時
在 @protocol 中定義的所有屬性
在 category 中定義的所有屬性
覆載的屬性
當你在子類中覆載父類的屬性時,必須使用 @synthesize 手動合成 ivar。
除了後三條,前面幾項可以歸納出一個規律:當你想手動管理 @property 的所有內容時,你會嘗試透過自行實作全部存取方法或使用 @dynamic 來達成;此時編譯器會認為你打算手動管理,於是停用自動合成。
因為有了自動合成,多數開發者已習慣不手動定義 ivar。但一旦你需要使用 ivar,而自動合成又失效了,就必須借助 @synthesize 手動合成。
@synthesize 還有一個應用場景,但不建議使用:透過它指定實例變數的名稱(如上題所示)。一般無須修改預設名,若所有人都堅持同一套方案,程式碼大家都能讀懂。
舉例說明應用場景:

結果編譯器報錯:

當你同時重寫了 setter 與 getter 時,系統就不會產生 ivar。這時有兩種選擇:
手動建立 ivar
使用 @synthesize foo = _foo; 關聯 @property 與 ivar
更多資訊請參考:When should I use @synthesize explicitly?
在 Objective-C 中向 nil 發送訊息是完全合法的——只是執行時不會有任何作用:
如果方法回傳的是物件,訊息會回傳 0(nil)。例如:
Person * motherInlaw = [[aPerson spouse] mother];
若 spouse 為 nil,則發送給 nil 的 mother 也會回傳 nil。
1)若方法回傳指標型別,且大小小於或等於 sizeof(void*),或為 float、double、long double、long long 等整數純量,發送給 nil 的訊息會回傳 0。
2)若回傳結構體,會回傳全欄位皆為 0 的結構體。
3)不屬於上述情況時,回傳值是未定義的。
具體原因:Objective-C 是動態語言,每個方法在執行時都會被轉為訊息發送,即 objc_msgSend(receiver, selector)。
貼一段 runtime 的原始碼來說明:
// runtime.h(類在runtime中的定義) // https://weibo.com/luohanchenyilong/ // https://github.com/ChenYilong
struct objc_class { Class isa OBJC_ISA_AVAILABILITY; //isa指針指向Meta Class,因為Objc的類的本身也是一個Object,為了處理這個關系,runtime就創造了Meta Class,當給類發送[NSObject alloc]這樣消息時,實際上是把這個消息發給了Class Object #if !__OBJC2__ Class super_class OBJC2_UNAVAILABLE; // 父類 const char *name OBJC2_UNAVAILABLE; // 類名 long version OBJC2_UNAVAILABLE; // 類的版本信息,默認為0 long info OBJC2_UNAVAILABLE; // 類信息,供運行期使用的一些位標識 long instance_size OBJC2_UNAVAILABLE; // 該類的實例變量大小 struct objc_ivar_list *ivars OBJC2_UNAVAILABLE; // 該類的成員變量鏈表 struct objc_method_list **methodLists OBJC2_UNAVAILABLE; // 方法定義的鏈表 struct objc_cache *cache OBJC2_UNAVAILABLE; // 方法緩存,對象接到一個消息會根據isa指針查找消息對象,這時會在method Lists中遍歷,如果cache了,常用的方法調用時就能夠提高調用的效率。 struct objc_protocol_list *protocols OBJC2_UNAVAILABLE; // 協議鏈表 #endif } OBJC2_UNAVAILABLE;
向物件發送訊息時,runtime 會依物件的 isa 指標找到它實際所屬的類別,再在該類別與父類的方法列表中尋找方法執行。而回傳內容是具體呼叫時才產生的。回到本題:若向 nil 發送訊息,在查找 isa 指標時位址就是 0,直接回傳,因此不會出錯。
原因同上題:該方法編譯後就是一次 objc_msgSend() 呼叫,大致如下:
((void ()(id, SEL))(void )objc_msgSend)((id)obj, sel_registerName("foo"));
也就是說,[obj foo]; 在動態編譯時會被轉為 objc_msgSend(obj, @selector(foo));。
簡單說:當你向某物件發送一個它並未實作的方法時。這可以透過「訊息轉發」來處理。
流程如下:向物件發送訊息時,runtime 依 isa 指標找到所屬類別,再依序在該類與父類的方法列表中尋找;若一直找到最頂層父類仍找不到,程式執行時就會崩潰並拋出 unrecognized selector sent to XXX。但在崩潰之前,Objective-C runtime 會給你三次挽救的機會:
Method resolution
runtime 會呼叫 +resolveInstanceMethod: 或 +resolveClassMethod:,讓你有機會提供實作。若你動態加入方法並回傳 YES,runtime 會重新啟動一次訊息發送;若回傳 NO,則進入下一步。
Fast forwarding
若目標物件實作了 -forwardingTargetForSelector:,runtime 會呼叫它,讓你把訊息轉發給其他物件。只要回傳的不是 nil 或 self,整個發送流程就會重啟,只是接收者換成你回傳的物件。之所以叫 Fast,是因為這一步不會建立任何新物件;下一步則會建立 NSInvocation,相對較慢。
Normal forwarding
最後一次機會。runtime 會先發送 -methodSignatureForSelector: 取得函數的參數與回傳型別。若回傳 nil,則發出 -doesNotRecognizeSelector:,程式此時崩潰。若回傳了函數簽章,runtime 會建立 NSInvocation 並向目標物件發送 -forwardInvocation:。
所有父類的成員變數與自己的成員變數,都存放在該物件對應的儲存空間中。
每個物件內部都有一個 isa 指標指向它的類別物件,類別物件中存放著:
1)物件方法列表(該物件能接收的訊息列表,保存在其對應的類別物件中)
2)成員變數列表
3)屬性列表
類別物件內部也有一個 isa 指標指向元類別(meta class),元類別中存放的是類別方法列表;類別物件內部還有一個 superclass 指標指向父類。

1)根物件是 NSObject,它的 superclass 指標指向 nil。
2)類別物件既然稱為物件,也是一個實例。類別物件中也有 isa 指標指向它的元類別,即類別物件是元類別的實例。元類別內部存放類別方法列表;根元類別的 isa 指標指向自己,superclass 指標指向 NSObject 類。
如圖:

指向它的類別物件,從而能透過類別物件找到該物件上的方法。
@implementation Son : Father - (id)init { self = [super init]; if (self) { NSLog(@"%@", NSStringFromClass([self class])); NSLog(@"%@", NSStringFromClass([super class])); } return self; } @end
答案:兩者都輸出 Son。
NSStringFromClass([self class]) = Son NSStringFromClass([super class]) = Son
解惑(以下內容摘自微博 @Chun_iOS 的博文《刨根問底 Objective-C Runtime(1)- Self & Super》):
這題考察的是對 self 與 super 的理解。self 是類別的隱藏參數,指向當前呼叫該方法的類別實例。而 super 是一個魔法關鍵字,本質上是編譯器標記,它和 self 指向同一個訊息接收者。
上例中無論呼叫 [self class] 還是 [super class],接收訊息的物件都是當前 Son *xxx 這個物件。差別在於:super 告訴編譯器,呼叫 class 這個方法時要從父類的方法列表中開始查找,而不是本類。
使用 self 呼叫時,從當前類的方法列表開始找,找不到再往父類找;使用 super 時則從父類的方法列表開始找。
真的是這樣嗎?繼續看。用 clang 改寫:
$ clang -rewrite-objc test.m
發現上述程式碼被轉換為:
NSLog((NSString *)&__NSConstantStringImpl__var_folders_gm_0jk35cwn1d3326x0061qym280000gn_T_main_a5cecc_mi_0, NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("class")))); NSLog((NSString *)&__NSConstantStringImpl__var_folders_gm_0jk35cwn1d3326x0061qym280000gn_T_main_a5cecc_mi_1, NSStringFromClass(((Class *)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){ (id)self, (id)class_getSuperclass(objc_getClass("Son")) }, sel_registerName("class"))));
可以看到,呼叫 [self class] 時會轉為 objc_msgSend,函數定義為:
id objc_msgSend(id self, SEL op, ...)
self 作為第一個參數傳入。
而呼叫 [super class] 時會轉為 objc_msgSendSuper,函數定義為:
id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
第一個參數是 objc_super 結構體,其定義如下:
struct objc_super { __unsafe_unretained id receiver; __unsafe_unretained Class super_class; };
結構體有兩個成員:第一個是 receiver,類似 objc_msgSend 的第一個參數 self;第二個記錄當前類的父類。
所以呼叫 [self class] 時,實際先呼叫 objc_msgSend,第一個參數是 Son 當前實例,然後在 Son 中找 - (Class)class,沒有,去父類 Father 找,也沒有,最後在 NSObject 中找到。而 - (Class)class 的實作就是回傳 self 的類別,故輸出 Son。
runtime 原始碼對 - (Class)class 的實作:
- (Class)class { return object_getClass(self); }
而呼叫 [super class] 時會轉為 objc_msgSendSuper。第一步先建構 objc_super 結構體,第一個成員是 self,第二個成員是 (id)class_getSuperclass(objc_getClass("Son")),結果為 Father。第二步在 Father 中找 - (Class)class,沒有,再到 NSObject 找,找到了。最後內部使用 objc_msgSend(objc_super->receiver, @selector(class)) 呼叫,此時已與 [self class] 相同,故輸出仍是 Son。
每個類別物件中都有一個方法列表,記錄著方法名稱、方法實作與參數型別。selector 本質上就是方法名稱,透過這個名稱即可在方法列表中找到對應的方法實作。
在 ARC 下不需要
在 MRC 中,對於使用 retain 或 copy 策略的,無論 MRC 還是 ARC 都不需要
2011 年版本的 Apple API 官方文件 Associative References 一節中有一個 MRC 環境下的例子:
// 在MRC下,使用runtime Associate方法關聯的對象,不需要在主對象dealloc的時候釋放 // https://weibo.com/luohanchenyilong/ (微博@iOS程序犭袁) // https://github.com/ChenYilong // 摘自2011年版本的Apple API 官方文檔 - Associative References static char overviewKey; NSArray *array = [[NSArray alloc] initWithObjects:@"One", @"Two", @"Three", nil]; // For the purposes of illustration, use initWithFormat: to ensure // the string can be deallocated NSString *overview = [[NSString alloc] initWithFormat:@"%@", @"First three numbers"]; objc_setAssociatedObject ( array, &overviewKey, overview, OBJC_ASSOCIATION_RETAIN ); [overview release]; // (1) overview valid [array release]; // (2) overview invalid
文件指出:在第 1 點時,overview 字串仍然有效,因為 OBJC_ASSOCIATION_RETAIN 策略指定了 array 會保留關聯物件;而當 array 在第 2 點被釋放時,overview 會被 release,此時也一併被配置掉。
既然關聯物件會被銷毀,具體時間點是什麼?根據 WWDC 2011 Session 322(第 36 分 22 秒)發布的記憶體銷毀時間表,被關聯的物件在其生命週期內會比物件本身晚很多才釋放——它們會在 NSObject -dealloc 呼叫的 object_dispose() 方法中釋放。
物件記憶體銷毀時間表分為四個步驟:
// 對象的內存銷毀時間表 // https://weibo.com/luohanchenyilong/ (微博@iOS程序犭袁) // https://github.com/ChenYilong // 根據 WWDC 2011, Session 322 (36分22秒)中發布的內存銷毀時間表 1. 調用 -release :引用計數變為零 * 對象正在被銷毀,生命周期即將結束. * 不能再有新的 __weak 弱引用, 否則將指向 nil. * 調用 [self dealloc] 2. 父類 調用 -dealloc * 繼承關系中最底層的父類 在調用 -dealloc * 如果是 MRC 代碼 則會手動釋放實例變量們(iVars) * 繼承關系中每一層的父類 都在調用 -dealloc 3. NSObject 調 -dealloc * 只做一件事:調用 Objective-C runtime 中的 object_dispose() 方法 4. 調用 object_dispose() * 為 C++ 的實例變量們(iVars)調用 destructors * 為 ARC 狀態下的 實例變量們(iVars) 調用 -release * 解除所有使用 runtime Associate方法關聯的對象 * 解除所有 __weak 引用 * 調用 free()
類別方法:
屬於類別物件
只能透過類別物件呼叫
其中的 self 是類別物件
可以呼叫其他類別方法
不能存取成員變數
不能直接呼叫物件方法
實例方法:
屬於實例物件
只能透過實例物件呼叫
其中的 self 是實例物件
可以存取成員變數
可直接呼叫其他實例方法
也可以透過類別名稱呼叫類別方法
未完待續。
下一篇文章將發布於此處。