這本指南始於 2013 年 11 月,最初只是想寫一份「如何撰寫乾淨漂亮的 Objective-C 程式碼」的說明。當時網路上已有不少規範,但它們大多流於死板條文。我們不想再加一本教條手冊,而是希望提供一條讓團隊成員寫出風格一致程式碼的路徑。隨著內容累積,這份文件逐漸從「風格約定」走向「如何設計與建構優秀的程式碼」。
核心觀點是:程式碼不能只是「可以編譯」,還應該是「有效」的。好程式碼具備幾個特徵——簡明、自我說明、組織良好、有完善的文件、命名得當、設計優秀,並且禁得起時間考驗。
本指南的一個基本立場是:清晰度優先於效能,並會說明為什麼值得這樣取捨。雖然所有範例都以 Objective-C 撰寫,但其中不少主題是跨語言通用的。
條件語句的內容主體應該總是被大括號包住。即使某次只有一行程式碼而省略了大括號,也會埋下隱患:新增一行時你可能誤以為它屬於 if 的範圍;更危險的是,如果把 if 之後那行註解掉,下一行就會莫名其妙地變成 if 的主體。
推薦:
if (!error) {
return success;
}
不推薦:
if (!error) return success;
2014 年 2 月,Apple 的 SSL/TLS 實作中發現了著名的 goto fail 缺陷,正是這種寫法造成的:
static OSStatus SSLVerifySignedServerKeyExchange(SSLContext *ctx, bool isRsa, SSLBuffer signedParams, uint8_t *signature, UInt16 signatureLen)
{
OSStatus err;
...
if ((err = SSLHashSHA1.update(&hashCtx, &serverRandom)) != 0)
goto fail;
if ((err = SSLHashSHA1.update(&hashCtx, &signedParams)) != 0)
goto fail;
goto fail;
if ((err = SSLHashSHA1.final(&hashCtx, &hashOut)) != 0)
goto fail;
...
fail:
SSLFreeBuffer(&signedHashes);
SSLFreeBuffer(&hashCtx);
return err;
}
兩行連續的 goto fail 沒有大括號保護,第二行永遠會被執行。其他條件語句也應維持同樣風格,方便逐行檢查。
尤達表達式指的是拿常量去跟變數比較,而不是拿變數跟常量比較。就像說「藍色是不是天空的顏色」,而不是「天空是不是藍的」。
推薦:
if ([myValue isEqual:@42]) { ... }
不推薦:
if ([@42 isEqual:myValue]) { ... }
nil 的檢查方式同樣存在爭議。有些知名函式庫這樣寫:
if (nil == myValue) { ... }
有人認為這形同尤達表達式,但採用的理由通常是為了避免除錯困難。考慮下面這段程式碼:
if (myValue == nil) { ... }
如果手滑打成:
if (myValue = nil) { ... }
這是合法語句,但即使經驗豐富、盯著看好幾遍也很難發現問題。反過來說,nil 不能被賦值,寫在左邊就不會出錯。
更推薦的做法是用驚嘆號作為運算子。因為 nil 會被解讀為 NO,條件式中不必與其他值比較;同時也不要直接與 YES 比較,因為 YES 定義為 1,而 BOOL 其實是 8 位元的 char。
推薦:
if (someObject) { ... }
if (![someObject boolValue]) { ... }
if (!someObject) { ... }
不推薦:
if (someObject == YES) { ... }
if (myRawValue == YES) { ... } // 絕對不要這樣寫
if ([someObject boolValue] == NO) { ... }
撰寫條件式時,程式碼左側的縮排應該是一條「黃金大道」或「快樂大道」。也就是盡量不要巢狀 if,改用多個 return 提前結束,如此能降低圈複雜度並提升可讀性——重要邏輯不會被埋在分支裡,讀者一眼就能找到。
推薦:
- (void)someMethod {
if (![someOther boolValue]) {
return;
}
// Do something important
}
不推薦:
- (void)someMethod {
if ([someOther boolValue]) {
// Do something important
}
}
遇到複雜的 if 子句,應該把它們各自抽成 BOOL 變數,讓邏輯更清楚,也讓每個子句的意義被明確命名。
BOOL nameContainsSwift = [sessionName containsString:@"Swift"];
BOOL isCurrentYear = [sessionDateCompontents year] == 2014;
BOOL isSwiftSession = nameContainsSwift && isCurrentYear;
if (isSwiftSession) {
// Do something very cool
}
三元運算子 ? 只應該用在能讓程式碼更清楚的地方,且條件式中的各個變數都應該已經被求值。與 if 類似,一次計算多個條件子句通常反而難懂,這時可以把它們重構到實例變數中。
推薦:
result = a > b ? x : y;
不推薦:
result = a > b ? x = c > d ? c : d : y;
當三元運算子的第二個運算元(真分支)回傳的就是條件式中檢查的同一個物件時,還有更精簡的寫法:
推薦:
result = object ?: [self createObject];
不推薦:
result = object ? object : [self createObject];
有些方法透過參數回傳 error 的參考,使用這類方法時應該檢查方法的回傳值,而不是 error 本身。
推薦:
NSError *error = nil;
if (![self trySomethingWithError:&error]) {
// Handle Error
}
此外,部分 Apple API 在成功的情況下會對 error 參數(若非 NULL)寫入垃圾值,因此檢查 error 的值可能導致錯誤甚至崩潰。
除非編譯器要求,case 內部通常不需要大括號;但當一個 case 包含多行語句時,就應該加上。
switch (condition) {
case 1:
// ...
break;
case 2: {
// 多行範例,使用大括號
break;
}
case 3:
// ...
break;
default:
// ...
break;
}
有時可用 fall-through 讓多個 case 共用同一段程式碼,做法就是省略 break:
switch (condition) {
case 1:
case 2:
// 數值 1 與 2 都會執行這裡
break;
default:
break;
}
當 switch 的運算式是列舉型別時,default 並非必要:
switch (menuType) {
case ZOCEnumNone:
break;
case ZOCEnumValue1:
break;
case ZOCEnumValue2:
break;
}
這樣做的好處是:一旦 enum 新增了值卻沒處理,編譯器立刻會警告 Enumeration value 'ZOCEnumValue3' not handled in switch。
使用 enum 時,建議改用固定底層型別的定義方式,它有更強的型別檢查與自動完成。SDK 提供了 NS_ENUM() 巨集來鼓勵這種寫法:
typedef NS_ENUM(NSUInteger, ZOCMachineState) {
ZOCMachineStateNone,
ZOCMachineStateIdle,
ZOCMachineStateRunning,
ZOCMachineStatePaused
};
盡可能遵守 Apple 的命名慣例,特別是與記憶體管理規則(NARC)相關的部分。方法與變數名稱應該長而具描述性。
推薦:UIButton *settingsButton;
不推薦:UIButton *setBut;
常量以駝峰式命名,並以相關類別名稱作為前綴。
推薦:
static const NSTimeInterval ZOCSignInViewControllerFadeOutAnimationDuration = 0.4;
不推薦:
static const NSTimeInterval fadeOutTime = 0.4;
建議用常量取代字串字面值與魔法數字,方便重複使用,也便於日後快速修改而不必搜尋取代。常量應以 static 宣告為靜態常量,除非它明確作為巨集使用,否則不要用 #define。
推薦:
static NSString * const ZOCCacheControllerDidClearCacheNotification = @"ZOCCacheControllerDidClearCacheNotification"; static const CGFloat ZOCImageThumbnailHeight = 50.0f;
不推薦:
#define CompanyName @"Apple Inc." #define magicNumber 42
對外公開的常量應在標頭檔中這樣宣告:
extern NSString *const ZOCCacheControllerDidClearCacheNotification;
並在實作檔中賦值。只有公開常量需要加上命名空間前綴;實作檔中的私有常量可以另循一套命名風格,但沿用同一規則也沒問題。
方法名稱與方法類型(- / + 符號)之間應以空格隔開,方法各段之間也應以空格隔開,以符合 Apple 風格。參數前應該總是有一個具描述性的關鍵詞。
盡量少用 and。它不該被用來串接多個參數,例如 initWithWidth:height: 這種寫法就足夠:
推薦:
- (void)setExampleText:(NSString *)text image:(UIImage *)image; - (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag; - (id)viewWithTag:(NSInteger)tag; - (instancetype)initWithWidth:(CGFloat)width height:(CGFloat)height;
不推薦:
- (void)setT:(NSString *)text i:(UIImage *)image; - (void)sendAction:(SEL)aSelector :(id)anObject :(BOOL)flag; - (id)taggedView:(NSInteger)tag; - (instancetype)initWithWidth:(CGFloat)width andHeight:(CGFloat)height; - (instancetype)initWith:(int)width and:(int)height; // 絕對不要這樣寫
使用字面值建立不可變的 NSString、NSDictionary、NSArray 與 NSNumber 物件。注意不要把 nil 傳進 NSArray 或 NSDictionary,否則會崩潰。
NSArray *names = @[@"Brian", @"Matt", @"Chris", @"Alex", @"Steve", @"Paul"];
NSDictionary *productManagers = @{@"iPhone" : @"Kate", @"iPad" : @"Kamal", @"Mobile Web" : @"Bill"};
NSNumber *shouldUseLiterals = @YES;
NSNumber *buildingZIPCode = @10018;
不要這樣寫:
NSArray *names = [NSArray arrayWithObjects:@"Brian", @"Matt", @"Chris", nil]; NSDictionary *productManagers = [NSDictionary dictionaryWithObjectsAndKeys:@"Kate", @"iPhone", nil]; NSNumber *shouldUseLiterals = [NSNumber numberWithBool:YES]; NSNumber *buildingZIPCode = [NSNumber numberWithInteger:10018];
若需要可變版本,請直接用 NSMutableArray、NSMutableString 等類別,而應該避免:
NSMutableArray *aMutableArray = [@[] mutableCopy];
這種寫法在效率與可讀性上都有問題。效率上,一個不必要的不可變物件被建立後立刻被丟棄;可讀性上,看到 @[] 讀者會先聯想到 NSArray,必須停下來細看,而新手甚至可能誤判這是可變還是不可變物件。
類別名稱應該以三個大寫字母作為前綴(雙字母前綴保留給 Apple)。這看似古怪,卻能有效緩解 Objective-C 沒有命名空間所帶來的問題。
有些開發者在定義模型物件時不遵守這條規則,但 Core Data 物件更應該嚴格遵循,因為最終你可能得把 Managed Object Model 與第三方庫的 MOM 合併。本指南中的前綴(包含公開常量、Protocol 等)統一為 ZOC。
另一個好習慣:建立子類別時,把描述性的部分放在前綴與父類別名稱之間。例如 ZOCNetworkClient 的子類別叫 ZOCTwitterNetworkClient,而 UIViewController 的子類別則是 ZOCTimelineViewController。
建議的組織順序是:dealloc 放在實作檔最前面(緊接 @synthesize 與 @dynamic 之後),init 跟在 dealloc 後面。若有多個初始化方法,指定初始化方法(designated initializer)放最前,其餘間接初始化方法跟在後面。
有了 ARC,dealloc 幾乎不必實作,但把 init 與 dealloc 放在一起能在視覺上強調它們成對出現:init 中做的事,往往需要在 dealloc 中撤銷。
- (instancetype)init {
self = [super init]; // 呼叫指定初始化方法
if (self) {
// 自訂的初始化流程
}
return self;
}
為什麼要把 self 設為 [super init] 的回傳值?這牽涉到 Objective-C 的「兩步建立」特性:配置記憶體與初始化被拆成 alloc 和 init 兩步。
alloc 負責建立物件:配置足夠的記憶體、寫入 isa 指標、初始化參考計數並重置所有實例變數,然後回傳一個有效但尚未初始化的實例。init 負責讓物件進入可用狀態,通常就是替實例變數賦予合理的值。依慣例,新建實例收到的第一個訊息就是 init,而 NSObject 的 init 實作只是單純回傳 self。
關於 init 還有一個重要約定:它可以(也應該)透過回傳 nil 來告訴呼叫者初始化失敗。失敗的原因很多,例如輸入格式錯誤,或另一個必需的物件初始化失敗。這也解釋了為什麼一定要寫 self = [super init]:如果父類別表示初始化失敗,你就必須假設自己處於不穩定狀態,放棄後續初始化並回傳 nil。否則你操作的是一個不可用物件,行為無法預測,最終可能導致崩潰。
此外,init 也可以透過重新指派 self 而回傳另一個實例——類簇,以及部分 Cocoa 類別對相等的(不可變)物件回傳同一實例,就是這個機制。
Objective-C 區分 designated initializer 與 secondary initializer。前者提供所有參數,後者提供一或多個預設值並轉而呼叫前者。
@implementation ZOCEvent
- (instancetype)initWithTitle:(NSString *)title date:(NSDate *)date location:(CLLocation *)location {
self = [super init];
if (self) {
_title = title;
_date = date;
_location = location;
}
return self;
}
- (instancetype)initWithTitle:(NSString *)title date:(NSDate *)date {
return [self initWithTitle:title date:date location:nil];
}
- (instancetype)initWithTitle:(NSString *)title {
return [self initWithTitle:title date:[NSDate date] location:nil];
}
@end
這裡 initWithTitle:date:location: 是指定初始化方法,另外兩個是間接初始化方法。
一個類別應該有且只有一個指定初始化方法,其他初始化方法都應呼叫它。在類別繼承鏈中,指定初始化方法應該由祖先(通常是 NSObject)向下依序呼叫,這代表最先執行的初始化程式碼屬於最遠的祖先,每個類別都有機會執行自己的初始化。Apple 的框架都保證遵守這個約定,你的類別也該如此。
定義新類別時有三種做法:一是完全不必覆寫任何初始化方法,直接沿用父類別的指定初始化方法;二是覆寫指定初始化方法;三是定義全新的指定初始化方法。
當你只是要加上額外的初始化邏輯時,採用第二種:覆寫直接父類別的指定初始化方法,並確保實作中呼叫了父類別的版本。典型例子是繼承 UIViewController 時覆寫 initWithNibName:bundle::
@implementation ZOCViewController
- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil {
self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
if (self) {
// 自訂的初始化流程
}
return self;
}
@end
在這個例子中,如果改去覆寫 init 就是錯誤的:呼叫者會嘗試用 initWithNibName:bundle: 初始化你的類別,你的實作根本不會被執行,也違反了「任何指定初始化方法都應可用」的規則。
若要提供自己的初始化方法,請依序完成四件事:定義你的指定初始化方法並確保呼叫直接父類別的指定初始化方法;覆寫直接父類別的指定初始化方法並轉而呼叫你的新方法;為新的指定初始化方法撰寫文件。很多開發者忽略後兩步,這不只是粗心,而是違反框架規則,可能導致難以預測的行為與 bug。
@implementation ZOCNewsViewController
- (id)initWithNews:(ZOCNews *)news {
self = [super initWithNibName:nil bundle:nil];
if (self) {
_news = news;
}
return self;
}
- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil {
return [self initWithNews:nil];
}
@end
如果你沒覆寫 initWithNibName:bundle:,而呼叫者用這個合法方法初始化你的類別,initWithNews: 永遠不會被執行,你的特定初始化邏輯也就被跳過了。
即使型別系統能推斷哪個是指定初始化方法,也最好明確寫出來。你可以用編譯器指令 __attribute__((objc_designated_initializer)) 標記意圖,這樣當新的指定初始化方法沒有呼叫父類別的指定初始化方法時,編譯器會警告。反過來,若某個初始化方法在語意上毫無意義(例如建立 ZOCNewsViewController 卻不傳入新聞),可以用 __attribute__((unavailable("Invoke the designated initializer"))) 讓呼叫它直接變成編譯錯誤。
@interface ZOCNewsViewController : UIViewController - (instancetype)initWithNews:(ZOCNews *)news ZOC_DESIGNATED_INITIALIZER; - (instancetype)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil ZOC_UNAVAILABLE_INSTEAD(initWithNews:); - (instancetype)init ZOC_UNAVAILABLE_INSTEAD(initWithNews:); @end
由此可推出一條規則:永遠不要從指定初始化方法中呼叫間接初始化方法,否則很可能被子類別覆寫的 init 攔截,陷入無限遞迴。
唯一的例外是類別遵循 NSCoding 協議、透過 initWithCoder: 初始化的情況。此時要看父類別是否也遵循 NSCoding:若是,你可能需要在指定初始化方法中放一些共用邏輯,好的做法是把這些程式碼抽到私有方法(如 p_commonInit);若父類別不遵循 NSCoding,則建議把 initWithCoder: 當作間接初始化方法並呼叫 self 的指定初始化方法。注意這與 Apple《Archives and Serializations Programming Guide》中「物件應先呼叫父類別的指定初始化方法以初始化繼承狀態」的說法相左;若你的類別不是 NSObject 的直接子類,照著做可能導致不可預測的行為。
間接初始化方法只負責提供預設值與行為,其中不應有初始化實例變數的操作,而且你應該永遠假設自己唯一被保證呼叫的成員是指定初始化方法。因此間接初始化方法一定要呼叫 self 的指定初始化方法(或你自訂的那個),若誤寫成 super,就會跳過當前類別的初始化。
Cocoa 充滿了約定,而這些約定能讓編譯器變得更聰明。無論遇到 alloc 或 init,編譯器都知道它們總是回傳接收者類別的實例,因此允許型別檢查——這被稱為 related result type:
messages sent to one of alloc and init methods will have the same static type as the instance of the receiver class
可以用 instancetype 關鍵字明確標示這種回傳型別,它在工廠方法與建構方法中特別有用,而且對子類別同樣有效。
@interface ZOCPerson + (instancetype)personWithName:(NSString *)name; @end
依 clang 的定義,id 可以被提升為 instancetype,但對於 alloc、init 以及所有回傳類別實例的類別方法與實例方法,我們強烈建議一律使用 instancetype。養成這個習慣並保持一致性,還能提升可讀性:瀏覽程式碼時,一眼就能分辨哪些方法會回傳自己類別的實例。
Apple 對類簇的描述是:一個在公開抽象父類別下聚集一組私有具體子類別的架構。聽起來耳熟嗎?沒錯,類簇就是 Apple 對抽象工廠模式的稱呼。
想法很簡單:初始化過程中,抽象類別(通常透過參數或環境判斷)決定要實例化哪一個具體子類別。這個「面向外界」的類別必須清楚自己的私有子類別,才能針對具體任務回傳合適的實例。呼叫者只需知道各種 API 的作用,複雜的初始化邏輯與背後實作都被隱藏起來。
Apple 的框架大量使用這個模式:NSNumber 會依數字型別(整數、浮點數等)回傳不同子類別,NSArray 也會依型別回傳最合適的儲存策略實作。精妙之處在於呼叫者完全不必理會子類別,因此設計函式庫時可以自由替換實際回傳的類別。我們的經驗是,善用類簇能移除大量條件判斷。
經典案例:同一個 UIViewController 子類別要同時支援 iPad 與 iPhone,但兩種裝置上的行為不同。基礎做法是到處寫條件判斷,初期還好,隨著程式碼增長會愈來愈難維護。更好的設計是建立一個抽象且寬廣的 view controller 承載共用邏輯,再針對兩種裝置各做一個子類別,由通用類別判斷當前裝置並回傳合適的子類別。
@implementation ZOCKintsugiPhotoViewController
- (id)initWithPhotos:(NSArray *)photos {
if ([self isMemberOfClass:ZOCKintsugiPhotoViewController.class]) {
self = nil;
if ([UIDevice isPad]) {
self = [[ZOCKintsugiPhotoViewController_iPad alloc] initWithPhotos:photos];
} else {
self = [[ZOCKintsugiPhotoViewController_iPhone alloc] initWithPhotos:photos];
}
return self;
}
return [super initWithNibName:nil bundle:nil];
}
@end
用 [self isMemberOfClass:...] 是為了避免子類別覆寫初始化方法時陷入無限遞迴。self = nil 的目的是解除抽象類別實例的所有參考,讓它被釋放(無論 ARC 或 MRC,dealloc 都會在本次 RunLoop 結束時發生)。後續邏輯則判斷該初始化哪一個私有子類別。
值得强调的是,這套寫法只有在完全遵循指定/間接初始化方法規範的前提下才會如預期運作;若對規範不熟,建議先回頭複習再來看這段說明。
如果可能,請盡量避免單例,改用依賴注入。若真的非用不可,請採用執行緒安全的建立方式。以 GCD 而言,dispatch_once() 就是答案:
+ (instancetype)sharedInstance {
static id sharedInstance = nil;
static dispatch_once_t onceToken = 0;
dispatch_once(&onceToken, ^{
sharedInstance = [[self alloc] init];
});
return sharedInstance;
}
它取代了過去那種 @synchronized 的老派寫法:
+ (instancetype)sharedInstance {
static id sharedInstance;
@synchronized(self) {
if (sharedInstance == nil) {
sharedInstance = [[MyClass alloc] init];
}
}
return sharedInstance;
}
dispatch_once() 更快、語法更乾淨,語意就是「把這段只做一次」,還能避免許多難以追蹤的崩潰。
典型的單例像是裝置的 GPS 與動作感測器。雖然單例可以被繼承,但真正有用的場合極少,而且必須有明確證據顯示該類別的介面就是傾向作為單例使用。既然如此,通常公開一個 sharedInstance 類別方法就足夠了,不需要暴露任何可寫屬性。把單例當成全域變數容器、到處共享狀態,是糟糕而醜陋的設計。
屬性應該描述性地命名、避免縮寫,並以小寫駝峰式開頭。工具能自動補全幾乎所有命名(Xcode 的 Derived Data 會建立索引),所以沒理由為了少打幾個字犧牲清晰度。
寫法上,星號應緊貼型別之後:
NSString *text;
不要寫成 NSString* text; 或 NSString * text;。
請使用自動合成(auto-synthesis),除非屬性是 protocol 的一部分而非完整類別的成員。既然 Xcode 能代勞,就讓它做,否則只是徒增維護成本。
除了 init 與 dealloc,你應該一律透過 setter 與 getter 存取屬性。這麼做的好處是:
使用 setter 會遵守宣告的記憶體管理語意(strong、weak、copy 等)。例如 copy 屬性會在每次賦值時複製資料,不必額外處理;KVO 通知(willChangeValueForKey、didChangeValueForKey)會自動觸發;除錯更容易,你可以在屬性宣告上設中斷點,或在自己的 setter/getter 中下斷點;也便於集中在一處加入額外邏輯。
傾向使用 getter 的理由則是:對未來變更有擴充能力(例如屬性改為動態產生)、允許子類別覆寫、除錯更簡單、意圖更明確——直接存取 ivar 容易變成 self->_anIvar 這種寫法而滋生問題,在 block 中存取 ivar 也會隱性 retain self;此外訊息派送的額外開銷微不足道。
永遠不要在 init(以及其他初始化方法)中使用 getter 與 setter,請直接存取實例變數。原因是:若存在子類別並覆寫了 setter 或 getter,初始化階段呼叫它們會導致子類別去操作尚未初始化完成的屬性。要記住,物件只有在 init 回傳之後才算完成初始化。dealloc 中的情況也類似,此時物件處於不確定狀態。
存取與設定屬性時盡量使用點語法,這能讓表達更清晰,也有助於區分屬性存取與方法呼叫。
view.backgroundColor = [UIColor orangeColor]; [UIApplication sharedApplication].delegate;
不要寫成 [view setBackgroundColor:[UIColor orangeColor]]; 或 UIApplication.sharedApplication.delegate;。
建議依下列格式定義屬性:
@property (nonatomic, readwrite, copy) NSString *name;
參數順序應為:原子性、讀寫、記憶體管理。這樣不僅可讀性更好,也更容易修改正確——因為人們調整修飾詞時通常從右往左找,而最右側的記憶體管理修飾詞正是最常被改動的。
除非有特殊需要,一定要用 nonatomic。在 iOS 上,atomic 帶來的鎖會明顯影響效能。屬性也可以存放程式碼區塊,為了讓 block 存活到定義它的作用域結束,必須加上 copy(block 預設建立在堆疊上,copy 會把它複製到堆上)。
若想要公開 getter、私有 setter,可在標頭檔宣告為 readonly,並在類別擴充中重新宣告為 readwrite:
// .h @interface MyClass : NSObject @property (nonatomic, readonly, strong) NSObject *object; @end // .m @interface MyClass () @property (nonatomic, readwrite, strong) NSObject *object; @end @implementation MyClass @end
若 BOOL 屬性的名稱是形容詞,setter 不應帶 is 前綴,但 getter 應該帶上:
@property (assign, getter=isEditable) BOOL editable;
私有屬性應定義在實作檔的類別擴充(匿名 category)中,不允許放在具名 category(如 ZOCPrivate)裡,除非你擴充的是其他類別。
@interface ZOCViewController () @property (nonatomic, strong) UIView *bannerView; @end
任何可以被可變物件設定的屬性(如 NSString、NSArray、NSURLRequest),記憶體管理類型必須是 copy。這樣能確保被封裝的物件值不會在不明確的情況下被改動:copy 屬性會在 setter 中產生不可變副本,避免外部持有的 NSMutableArray 內容被隨意變更。
同時應避免在公開介面暴露可變物件,因為那會讓使用者改動類別的內部表示並破壞封裝。可以提供唯讀屬性回傳不可變副本:
/* .h */
@property (nonatomic, readonly) NSArray *elements;
/* .m */
- (NSArray *)elements {
return [self.mutableElements copy];
}
當建立某個物件成本很高,或需要一堆設定程式碼又不想弄亂 init 時,可以覆寫 getter 以延遲建立。常見模板如下:
- (NSDateFormatter *)dateFormatter {
if (!_dateFormatter) {
_dateFormatter = [[NSDateFormatter alloc] init];
NSLocale *enUSPOSIXLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US_POSIX"];
[_dateFormatter setLocale:enUSPOSIXLocale];
[_dateFormatter setDateFormat:@"yyyy-MM-dd'T'HH:mm:ss.SSS"]; // 毫秒是 SSS,不是 SSSSS
}
return _dateFormatter;
}
某些情況下這確實好用,但採用前值得深思,因為它其實是可以避免的。反對的理由有幾點:getter 應該避免副作用,看到 getter 你不會預期它建立物件,編譯器甚至會對「僅因副作用而呼叫 getter」發出警告;第一次存取時才付出初始化成本,會讓效能優化與測試變得困難;初始化時機變得不可預期,一旦類別實作改變、存取器提早被呼叫就可能出問題,特別是當初始化邏輯依賴類別的其他狀態時;這行為對 KVO 不友善——若 getter 改變了參考,理應發出 KVO 通知,但在讀取時收到變更通知相當怪異。
若方法要求某些參數滿足特定條件(例如不可為 nil),建議用 NSParameterAssert() 斷言條件成立,否則拋出異常。
永遠不要替私有方法加上 _ 前綴,那是 Apple 保留的。不要冒覆寫 Apple 私有方法的風險。
實作相等性時請記住這個約定:需要同時實作 isEqual 與 hash。若兩個物件被 isEqual 判定相等,它們的 hash 必須回傳相同的值;但 hash 相同並不代表兩者相等。這個約定在物件被放進集合(NSDictionary、NSSet 底層使用雜湊表)時至關重要。
@implementation ZOCPerson
- (BOOL)isEqual:(id)object {
if (self == object) {
return YES;
}
if (![object isKindOfClass:[ZOCPerson class]]) {
return NO;
}
return [self isEqualToPerson:(ZOCPerson *)object];
}
- (BOOL)isEqualToPerson:(ZOCPerson *)person {
if (!person) {
return NO;
}
BOOL namesMatch = (!self.name && !person.name) || [self.name isEqualToString:person.name];
BOOL birthdaysMatch = (!self.birthday && !person.birthday) || [self.birthday isEqualToDate:person.birthday];
return namesMatch && birthdaysMatch;
}
- (NSUInteger)hash {
return [self.name hash] ^ [self.birthday hash];
}
@end
hash 千萬不能回傳常量。這是常見錯誤且後果嚴重:hash 值作為物件在雜湊表中的 key,回傳常量會導致近乎 100% 的碰撞。
你也應該一律以 isEqualTo<ClassName>: 的格式實作相等性檢查,這樣系統會優先呼叫它,省去型別判斷。
hash 的計算結果必須是確定的。當物件被加入 NSArray、NSSet 或 NSDictionary 時,容器會依賴 hash 來查找物件或判定唯一性,否則行為將無法預測。因此應以不可變屬性計算 hash,更好的作法是讓物件本身不可變。此外,實作 hash 時應該建立在系統現成的 hash 方法之上,自行發明雜湊演算法通常會同時損害效能與準確性。
雖然寫起來有點醜,但我們應該在 category 方法前加上自己的小寫前綴與底線,例如 - (id)zoc_myCategoryMethod。Apple 也推薦這種做法。
這件事非常必要:如果擴充的 category 或其他 category 已使用相同方法名稱,後果無從預期——實際被呼叫的是最後載入的那個實作。若想確認自己的分類方法是否覆蓋了別人的實作,可以把環境變數 OBJC_PRINT_REPLACED_METHODS 設為 YES,被取代的方法名稱會印到 Console。目前 LLVM 5.1 不會對此發出任何警告,所以務必小心。
好的實踐是在 category 名稱本身也加上前綴:
@interface NSDate (ZOCTimeExtensions) - (NSString *)zoc_timeAgoShort; @end
不要寫成 - (NSString *)timeAgoShort;。
Category 也適合用來在標頭檔中定義一組功能相近的方法,這在 Apple 的框架中很常見(例如下面取自 NSDate 標頭檔的寫法),我們也強烈建議在自己的程式碼中採用。
@interface NSDate : NSObject <NSCopying, NSSecureCoding> @property (readonly) NSTimeInterval timeIntervalSinceReferenceDate; @end @interface NSDate (NSDateCreation) + (instancetype)date; + (instancetype)dateWithTimeIntervalSinceNow:(NSTimeInterval)secs; + (instancetype)dateWithTimeIntervalSinceReferenceDate:(NSTimeInterval)ti; + (instancetype)dateWithTimeIntervalSince1970:(NSTimeInterval)secs; + (instancetype)dateWithTimeInterval:(NSTimeInterval)secsToBeAdded sinceDate:(NSDate *)date; @end
我們的經驗是,把方法分組能大幅便利後續重構。當一個類別的介面不斷膨脹,往往意味著它做了太多事,違反單一職責原則;既有的分組則可以作為切分的依據,把類別拆成更多自足的組成部分。
Objective-C 世界裡常被忽略的一樣東西是抽象介面。「介面」一詞通常指類別的 .h 檔,但對 Java 開發者而言,它意味著一系列不依賴具體實作的方法定義。在 Objective-C 中,這由 protocol 實現。
因為歷史原因,protocol 這種用法並未在 Objective-C 社群普及:多數 Apple 程式碼只在委派模式下使用 protocol,而幾乎所有開發者都跟隨 Apple 的模式與指南。但抽象介面的概念強大且源流久遠,沒有理由不採用。
以下用一個 RSS 閱讀器(技術面試的常見題目)說明 protocol 的力量:需求很簡單,在 TableView 中展示一個遠端 RSS 訂閱。幼稚的做法是建立一個 UITableViewController 子類別,把抓取、解析、展示邏輯全塞進去——能跑,但設計糟糕,也就是所謂的 Massive View Controller。
第一步是遵循單一職責原則,至少拆成兩個部分:一個 feed 解析器負責解析資料,一個 feed 閱讀器負責顯示結果。
@interface ZOCFeedParser : NSObject @property (nonatomic, weak) id<ZOCFeedParserDelegate> delegate; @property (nonatomic, strong) NSURL *url; - (id)initWithURL:(NSURL *)url; - (BOOL)start; - (void)stop; @end @interface ZOCTableViewController : UITableViewController - (instancetype)initWithFeedParser:(ZOCFeedParser *)feedParser; @end
我們用下面這個 protocol 實作委派:
@protocol ZOCFeedParserDelegate <NSObject> @optional - (void)feedParserDidStart:(ZOCFeedParser *)parser; - (void)feedParser:(ZOCFeedParser *)parser didParseFeedInfo:(ZOCFeedInfoDTO *)info; - (void)feedParser:(ZOCFeedParser *)parser didParseFeedItem:(ZOCFeedItemDTO *)item; - (void)feedParserDidFinish:(ZOCFeedParser *)parser; - (void)feedParser:(ZOCFeedParser *)parser didFailWithError:(NSError *)error; @end
組裝起來就是:
NSURL *feedURL = [NSURL URLWithString:@"https://www.bbc.co.uk/feed.rss"]; ZOCFeedParser *feedParser = [[ZOCFeedParser alloc] initWithURL:feedURL]; ZOCTableViewController *tableViewController = [[ZOCTableViewController alloc] initWithFeedParser:feedParser]; feedParser.delegate = tableViewController;
但捫心自問:這裡有多少程式碼是可以真正重複使用的?view controller 只能處理 ZOCFeedParser 型別的物件,我們只是把程式碼切成兩塊,沒做其他有價值的事。view controller 的職責應該是「顯示某個東西提供的內容」,因此它需要一個更泛型的參數型別。
於是定義 ZOCFeedParserProtocol:
@protocol ZOCFeedParserProtocol <NSObject> @property (nonatomic, weak) id<ZOCFeedParserDelegate> delegate; @property (nonatomic, strong) NSURL *url; - (BOOL)start; - (void)stop; @end @protocol ZOCFeedParserDelegate <NSObject> @optional - (void)feedParserDidStart:(id<ZOCFeedParserProtocol>)parser; - (void)feedParser:(id<ZOCFeedParserProtocol>)parser didParseFeedInfo:(ZOCFeedInfoDTO *)info; - (void)feedParser:(id<ZOCFeedParserProtocol>)parser didParseFeedItem:(ZOCFeedItemDTO *)item; - (void)feedParserDidFinish:(id<ZOCFeedParserProtocol>)parser; - (void)feedParser:(id<ZOCFeedParserProtocol>)parser didFailWithError:(NSError *)error; @end
代理 protocol 改為回應新的 protocol,而 ZOCFeedParser 的介面變得更精煉:
@interface ZOCFeedParser : NSObject <ZOCFeedParserProtocol> - (id)initWithURL:(NSURL *)url; @end @interface ZOCTableViewController : UITableViewController <ZOCFeedParserDelegate> - (instancetype)initWithFeedParser:(id<ZOCFeedParserProtocol>)feedParser; @end
改動看起來不多,帶來的提升卻很大:view controller 改以 protocol 而非具體實作為基礎運作。好處是它現在能接受任何遵循該協議的物件——遠端 RSS 解析器、本機解析器,或任何透過 delegate 提供資料的服務;ZOCFeedParser 與 ZOCFeedParserDelegate 可被其他部分重用;ZOCViewController 本身也可重用;測試變簡單了,因為可以用 mock 物件滿足 protocol 的預期。
實作 protocol 時請時刻堅持里氏替換原則:你應該能以任意介面實作替換另一個實作,而不必改動呼叫端。這也意味著 protocol 不該關心類別的實作細節,設計抽象表述時要非常用心,並牢記它與背後的實作無關,真正重要的是暴露給使用者的那份契約。
定義自有的 NSNotification 時,應把通知名稱定義為字串常量,就像其他對外公開的字串常量一樣:在公開標頭檔中宣告為 extern,並在對應的實作檔中定義。由於你在標頭檔中暴露了符號,名稱需遵循統一的前綴慣例,並建議使用 Did/Will 這類動詞加上 Notifications 後綴。
// Foo.h extern NSString * const ZOCFooDidBecomeBarNotification; // Foo.m NSString * const ZOCFooDidBecomeBarNotification = @"ZOCFooDidBecomeBarNotification";
縮排使用 4 個空格,永遠不要用 tab,請確認 Xcode 設定也是如此。方法與其他大括號(if/else/switch/while 等)總是在同一行開始、另起一行結束。
if (user.isHappy) {
// Do something
} else {
// Do something else
}
方法之間應留一個空行,讓程式碼看起來清晰有組織;方法內部的空白則用來區隔功能區塊,但通常不同功能應該拆成不同方法。優先使用自動合成,若必須撰寫 @synthesize 與 @dynamic,請另起一行。
永遠讓冒號對齊。有些方法簽名可能有兩個以上的冒號,對齊能明顯提升可讀性;即使參數中有程式碼區塊也一樣。
[UIView animateWithDuration:1.0
animations:^{
// something
}
completion:^(BOOL finished) {
// something
}];
如果自動對齊反而讓可讀性變差,就該把 block 抽成變數,或重新思考你的方法簽名設計。
換行同樣重要。以 self.productsRequest = [[SKProductsRequest alloc] initWithProductIdentifiers:productIdentifiers]; 這樣的長行為例,續行應以兩個空格的間隔縮排延續。
括號方面,控制語句(if-else、for、switch)使用 Egyptian 風格(K&R 風格,左括號位於行尾);類別實作與方法實作則可使用非 Egyptian 風格。
code organization is a matter of hygiene
我們十分贊同這句話。清楚組織程式碼、規範地進行定義,是你對自己以及其他閱讀者的尊重。
GCC 有個略微冷門、Clang 也支援的特性:若程式碼區塊被包在閉合的圓括號內,會回傳最後一句表達式的值。
NSURL *url = ({
NSString *urlString = [NSString stringWithFormat:@"%@/%@", baseURLString, endpoint];
[NSURL URLWithString:urlString];
});
#pragma mark - 是在類別內部組織程式碼、分組方法實作的好幫手。建議用它區隔:不同功能組的方法、protocol 的實作、對父類別方法的覆寫。
- (void)dealloc { }
- (instancetype)init { }
#pragma mark - View Lifecycle
- (void)viewDidLoad { }
- (void)viewWillAppear:(BOOL)animated { }
#pragma mark - Custom Accessors
- (void)setCustomProperty:(id)value { }
- (id)customProperty { }
#pragma mark - IBActions
- (IBAction)submitData:(id)sender { }
#pragma mark - Public
- (void)publicMethod { }
#pragma mark - Private
- (void)zoc_privateMethod { }
#pragma mark - UITableViewDataSource
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath { }
#pragma mark - ZOCSuperclass
// 覆寫自 ZOCSuperclass 的方法
#pragma mark - NSObject
- (NSString *)description { }
這些標記能清楚切分與組織程式碼,你還可以用 cmd + 點擊快速跳轉到符號定義。但別忘了,pragma mark 再怎麼精緻,也不構成讓類別塞進大量方法的理由——方法太多,往往意味著該重構了。
多數 iOS 開發者平常很少與編譯器選項打交道。有時你會想直接介入編譯器行為。例如使用 ARC 時,若透過 NSSelectorFromString 動態產生 selector,ARC 不知道該用哪種記憶體管理方式,就會提示 performSelector may cause a leak because its selector is unknown。如果你確定不會洩漏記憶體,可以這樣局部關閉該警告:
#pragma clang diagnostic push #pragma clang diagnostic ignored "-Warc-performSelector-leaks" [myObj performSelector:mySelector withObject:name]; #pragma clang diagnostic pop
注意我們是在相關程式碼的上下文中停用檢查,而不是全域關閉——全域關閉可能埋下真正的錯誤。
有時你想保留某個宣告但暫時不用它。消除這類警告的好方法是加上 #pragma unused() 註解:
- (NSInteger)giveMeFive {
NSString *foo;
#pragma unused (foo)
return 5;
}
編譯器會依 Clang 規則標記問題,但你通常比它更了解脈絡。若某段程式碼暫時無解,可以明確標記:
- (NSInteger)divide:(NSInteger)dividend by:(NSInteger)divisor {
#error Whoa, buddy, you need to check for zero here!
return (dividend / divisor);
}
- (float)divide:(float)dividend by:(float)divisor {
#warning Dude, don't compare floating point numbers like this!
if (divisor != 0.0) {
return (dividend / divisor);
} else {
return NAN;
}
}
所有重要的方法、介面、分類與協議定義都應該有註解說明用途與用法。短文書適用於單行情況,包含註解斜線,適合簡短(尤其是非公開)的 API,並應以動詞(如 return)而非 returns 起頭:
// Return a user-readable form of a Frobnozz, html-escaped.
若描述超過一行,改用長格式:以 /** 開頭,換行寫一句總結並以句號結尾,空一行後在對齊位置續寫其餘內容,最後以 */ 結束。
/** * This comment serves to demonstrate the format of a docstring. * Note that the summary line is always at most one line long. */
字串文件應該描述函式的呼叫符號與語意,而不是它的實作方式。
註解應該用來解釋特定程式碼做了什麼,而且必須持續維護,否則乾脆刪掉。應避免大段區塊註解——程式碼本身該盡可能像文件一樣表達意圖(用來產生文件的註解除外)。類別的文件只寫在 .h 檔中,採用 Doxygen/AppleDoc 語法,方法與屬性都應附上說明。
/**
* Designated initializer.
*
* @param store The store for CRUD operations.
* @param searchService The search service used to query the store.
*
* @return A ZOCCRUDOperationsStore object.
*/
- (instancetype)initWithOperationsStore:(id<ZOCGenericStoreProtocol>)store
searchService:(id<ZOCGenericSearchServiceProtocol>)searchService;
再非凡的軟體也要靠物件通訊完成目標。以下幾節討論相關的設計概念。
Block 是 Objective-C 版的 lambda 或閉包。定義非同步介面時可以這樣寫:
- (void)downloadObjectsAtPath:(NSString *)path
completion:(void(^)(NSArray *objects, NSError *error))completion;
請盡量只用一個 block,並放在參數列表最後。把要提供的資料與錯誤資訊整合在同一個 block 中,比分開給成功與失敗兩個 block 更好,原因有幾點:成功與失敗處理常共用程式碼(例如收起進度條);Apple 自己也是這樣做,與平台一致能帶來好處;block 往往有多行,若不放在最後會破壞呼叫點的可讀性;多個 block 參數會讓呼叫顯得笨拙且複雜。
完成用的 block 參數有慣例:第一個是要取得的資料,第二個是錯誤資訊,並需滿足:objects 不為 nil 時 error 必須為 nil;objects 為 nil 時 error 必須不為 nil。因為呼叫者更在意實際資料:
- (void)downloadObjectsAtPath:(NSString *)path
completion:(void(^)(NSArray *objects, NSError *error))completion {
if (objects) {
// 處理資料
} else {
// 依契約,此時 error 必定不為 nil
}
}
幾個關鍵事實:block 建立在堆疊上,也可以複製到堆上;block 會擷取堆疊上的變數(或指標)並複製為自己私有的 const 副本,若想在 block 內修改外部變數,該變數必須以 __block 宣告。
若 block 沒有被其他地方持有,它會隨著堆疊存在,並在堆疊框返回時消失;此時它對物件的記憶體管理與生命週期沒有任何影響。若需要在堆疊框返回後存活,就必須明確複製到堆上,這時 block 會像其他 Cocoa 物件一樣增加參考計數,並 retain 它擷取的所有物件。
如果 block 參考了某個堆疊變數,它初始時持有的是該變數的 const 副本,因此事後在堆疊中改動原變數並不會生效:
CGFloat blockInt = 10;
void (^playblock)(void) = ^{ NSLog(@"blockInt = %zd", blockInt); };
blockInt++;
playblock(); // 輸出:blockInt = 10
當 block 被複製後,__block 宣告的堆疊變數參考會被複製到堆上,之後堆疊上的 block 與堆上的副本都會參照該變數在堆上的複本。
最重要的一點是:__block 宣告的變數與指標在 block 內被視為「可實際操作其真實值/物件的結構」。block 在 Objective-C runtime 中被視為一等公民,它有 isa 指標;在非 ARC 環境下處理不當會導致懸掛指標與崩潰。__block 只對 block 內的變數起作用,它相當於告訴編譯器:請用堆疊上的新變數來參照它,也就是对它做雙重解引用,不要 retain 它。若物件在 block 定義之後、被呼叫之前就已釋放,block 執行時就會崩潰——__block 變數不會被 block 持有。
使用 block 與非同步派送時,務必避免循環參考。請一律用 weak 參照物件,並在適當時把持有 block 的屬性設為 nil(如 self.completionBlock = nil;),這能打破 block 擷取作用域所帶來的循環。
__weak __typeof(self) weakSelf = self;
[self executeBlock:^(NSData *data, NSError *error) {
[weakSelf doSomethingWithData:data];
}];
不要這樣寫:
[self executeBlock:^(NSData *data, NSError *error) {
[self doSomethingWithData:data];
}];
多個語句時:
__weak __typeof(self) weakSelf = self;
[self executeBlock:^(NSData *data, NSError *error) {
__strong __typeof(weakSelf) strongSelf = weakSelf;
if (strongSelf) {
[strongSelf doSomethingWithData:data];
[strongSelf doSomethingWithData:data];
}
}];
建議把這兩行加進 Xcode 的 code snippet,隨手取用:
__weak __typeof(self) weakSelf = self; __strong __typeof(weakSelf) strongSelf = weakSelf;
block 中 self 的 __weak 與 __strong 有幾種細膩差別,可分為三種情況。
方案一:直接在 block 內使用 self。此時物件會在 block 定義時被 retain。若 block 只是被傳遞出去還無妨,但若它被存成 self 的屬性,就形成 retain cycle:
self.completionHandler = ^{ NSLog(@"%@", self); };
這時 CLANG 會警告 Capturing 'self' strongly in this block is likely to lead to a retain cycle,於是我們需要 __weak。
方案二:在 block 外定義 weak 參照並在 block 內使用。這能避免循環參考,是 block 作為屬性被 self 持有時的標準做法:
__weak typeof(self) weakSelf = self;
self.completionHandler = ^{ NSLog(@"%@", weakSelf); };
block 不 retain 物件,物件在屬性中 retain block,因此不會循環。缺點是 weakSelf 可能已被設為 nil,特別是當 block 被複製到另一個物件、而原物件在執行前已釋放時。
方案三:在 block 外定義 weak 參照,並在 block 內透過它定義 strong 參照。這不只是消除警告的技巧——強參照是在 block 執行時才建立,因此 self 在整個 block 執行期間都會被 retain:
__weak typeof(self) weakSelf = self;
myObj.myBlock = ^{
__strong typeof(self) strongSelf = weakSelf;
if (strongSelf) {
[strongSelf doSomething];
[strongSelf doSomethingElse];
} else {
return;
}
};
在 ARC 下,若嘗試用 -> 直接存取 __weak 變數的實例變數,編譯器會給出很清楚的錯誤:Dereferencing a __weak pointer is not allowed due to possible null value caused by race condition, assign it to a strong variable first.
總結:方案一只能用在 block 不是屬性的場合,否則會 retain cycle;方案二適合 block 被宣告為屬性時;方案三與並發執行有關,當 block 可能稍後才執行、又不希望 self 中途消失時使用。
委派模式在 Apple 框架中無所不在,也是《設計模式》中的重要一章。它是單向的:訊息發送方(委托方)需要知道接收方(代理方)是誰,反之則否;兩者耦合鬆散,發送方只需確認對方遵循相關 protocol。
本質上,委派模式只需要代理方提供一組回呼方法。不幸的是 Apple 的 API 並未严格遵守這點,開發者也跟著走進誤區,典型例子就是 UITableViewDelegate。
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath;
這些回傳 void 的方法確實是回呼。但另一些並非如此:
- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath; - (BOOL)tableView:(UITableView *)tableView canPerformAction:(SEL)action forRowAtIndexPath:(NSIndexPath *)indexPath withSender:(id)sender;
當委托方反過來向代理方索取資訊時,資料流向是相反的,這在概念上屬於另一種模式,應該有另一個名字:資料來源模式。Apple 雖然有 UITableViewDataSource,卻仍冠以「delegate」之名。為了區分概念,我們應該這樣定義:委派模式用於事件發生時通知代理方;資料來源模式則是委托方需要向資料來源物件索取資料。
@class ZOCSignUpViewController; @protocol ZOCSignUpViewControllerDelegate <NSObject> - (void)signUpViewControllerDidPressSignUpButton:(ZOCSignUpViewController *)controller; @end @protocol ZOCSignUpViewControllerDataSource <NSObject> - (ZOCUserCredentials *)credentialsForSignUpViewController:(ZOCSignUpViewController *)controller; @end @interface ZOCSignUpViewController : UIViewController @property (nonatomic, weak) id<ZOCSignUpViewControllerDelegate> delegate; @property (nonatomic, weak) id<ZOCSignUpViewControllerDataSource> dataSource; @end
代理方法必須以委托方作為第一個參數,否則代理方無法分辨不同的委托方實例。因此這種寫法令人髮指:
- (void)calculatorDidCalculateValue:(CGFloat)value;
預設情況下代理方需實作 protocol 中的所有方法,可用 @required 與 @optional 標記:
@protocol ZOCSignUpViewControllerDelegate <NSObject> @required - (void)signUpViewController:(ZOCSignUpViewController *)controller didProvideSignUpInfo:(NSDictionary *)dict; @optional - (void)signUpViewControllerDidPressSignUpButton:(ZOCSignUpViewController *)controller; @end
對於可選方法,委托方在送出訊息前必須先確認對方是否實作,否則會崩潰:
if ([self.delegate respondsToSelector:@selector(signUpViewControllerDidPressSignUpButton:)]) {
[self.delegate signUpViewControllerDidPressSignUpButton:self];
}
假設 UIViewControllerB 繼承自 UIViewControllerA,而 A 遵循 UITableViewDelegate 並實作了 heightForRowAtIndexPath:。你可能想在 B 中提供不同實作:
- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
CGFloat retVal = 0;
if ([super respondsToSelector:@selector(tableView:heightForRowAtIndexPath:)]) {
retVal = [super tableView:self.tableView heightForRowAtIndexPath:indexPath];
}
return retVal + 10.0f;
}
問題是,respondsToSelector: 的接收者是 self,它會沿著 self 的型別查找並確認方法存在,於是下一行就會崩潰:-[UIViewControllerB tableView:heightForRowAtIndexPath:]: unrecognized selector sent to instance。正確作法是詢問特定的類別:
- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
CGFloat retVal = 0;
if ([[UIViewControllerA class] instancesRespondToSelector:@selector(tableView:heightForRowAtIndexPath:)]) {
retVal = [super tableView:self.tableView heightForRowAtIndexPath:indexPath];
}
return retVal + 10.0f;
}
不過更理想的方式是重新設計架構,讓代理方法根本不需要被覆寫。
多重委派是個基礎概念,卻少有人熟悉,大家往往直接改用 NSNotification。委派與資料來源只牽涉兩個物件,但有些場景下會有多個物件關心同一個委托方的回呼。
資料來源模式強制一對一;代理模式則允許有多個代理方等待回呼。在分散式系統與大型軟體的複雜資訊流中,這種做法相當常見。實作方式很多,Luca Bernardi 的 LBDelegateMatrioska 提供了一個相當簡潔的範式。
以下是最基本的實作。Cocoa 中也有在資料結構裡保存 weak 參照以避免循環引用的做法,這裡我們用一個類別來包裝代理物件的 weak 參照:
@interface ZOCWeakObject : NSObject
@property (nonatomic, readonly, weak) id object;
+ (instancetype)weakObjectWithObject:(id)object;
- (instancetype)initWithObject:(id)object;
@end
@implementation ZOCWeakObject
+ (instancetype)weakObjectWithObject:(id)object {
return [[[self class] alloc] initWithObject:object];
}
- (instancetype)initWithObject:(id)object {
if ((self = [super init])) {
_object = object;
}
return self;
}
- (BOOL)isEqual:(id)object {
if (self == object) {
return YES;
}
if (![object isKindOfClass:[object class]]) {
return NO;
}
return [self isEqualToWeakObject:(ZOCWeakObject *)object];
}
- (BOOL)isEqualToWeakObject:(ZOCWeakObject *)object {
if (!object) {
return NO;
}
return [self.object isEqual:object.object];
}
- (NSUInteger)hash {
return [self.object hash];
}
@end
接著用它組出多重代理的基礎元件:
@protocol ZOCServiceDelegate <NSObject>
@optional
- (void)generalService:(ZOCGeneralService *)service didRetrieveEntries:(NSArray *)entries;
@end
@interface ZOCGeneralService : NSObject
- (void)registerDelegate:(id<ZOCServiceDelegate>)delegate;
- (void)deregisterDelegate:(id<ZOCServiceDelegate>)delegate;
@end
@interface ZOCGeneralService ()
@property (nonatomic, strong) NSMutableSet *delegates;
@end
@implementation ZOCGeneralService
- (void)registerDelegate:(id<ZOCServiceDelegate>)delegate {
if ([delegate conformsToProtocol:@protocol(ZOCServiceDelegate)]) {
[self.delegates addObject:[[ZOCWeakObject alloc] initWithObject:delegate]];
}
}
- (void)deregisterDelegate:(id<ZOCServiceDelegate>)delegate {
if ([delegate conformsToProtocol:@protocol(ZOCServiceDelegate)]) {
[self.delegates removeObject:[[ZOCWeakObject alloc] initWithObject:delegate]];
}
}
- (void)_notifyDelegates {
for (ZOCWeakObject *object in self.delegates) {
if (object.object) {
if ([object.object respondsToSelector:@selector(generalService:didRetrieveEntries:)]) {
[object.object generalService:self didRetrieveEntries:entries];
}
}
}
}
@end
有了 registerDelegate: 與 deregisterDelegate:,掛上與解除關係都很直覺:代理方不再需要回呼時,只要「取消訂閱」。當多個 view 等待同一個回呼來更新畫面時,這特別有用——view 只是暫時隱藏而非銷毀,取消訂閱即可。
Aspect Oriented Programming(AOP)在 Objective-C 社群知名度不高,因為 Apple 沒有提供現成方案、業界也缺乏事實標準,但它能在執行期展現巨大威力。
An aspect can alter the behavior of the base code by applying advice (additional behavior) at various join points specified in a quantification or query called a pointcut.
在 Objective-C 中,這意味著利用 runtime 特性為指定方法附加「切面」。附加的行為可以是:在特定方法呼叫前執行程式碼、呼叫後執行程式碼,或替換原本的實作。
實現方式不少,但大多依賴 runtime。Peter Steinberger 的 Aspects 庫非常契合這個思路,設計優秀且值得信賴。它的 API 簡潔而強大:
+ (id)aspect_hookSelector:(SEL)selector withOptions:(AspectOptions)options usingBlock:(id)block error:(NSError **)error; - (id)aspect_hookSelector:(SEL)selector withOptions:(AspectOptions)options usingBlock:(id)block error:(NSError **)error;
例如,下面的程式碼會在 MyClass 的 myMethod: 執行完之後,執行 block 中的內容:
[MyClass aspect_hookSelector:@selector(myMethod:)
withOptions:AspectPositionAfter
usingBlock:^(id aspectInfo) {
...
}
error:nil];
也就是說,任何 MyClass 型別的物件(若為類別方法則是類別本身)在執行 myMethod: 之後,就會執行我們附加的程式碼——我們為 myMethod: 加上了一個切面。
AOP 通常用來實現橫向關注點,統計與日誌是最典型的例子。多數統計框架(Google Analytics、Flurry、MixPanel 等)都要求你在每個類別裡寫幾行追蹤程式碼:
- (void)logButtonPress:(UIButton *)button {
id<GAITracker> tracker = [[GAI sharedInstance] defaultTracker];
[tracker send:[[GAIDictionaryBuilder createEventWithCategory:@"UX"
action:@"touch"
label:[button.titleLabel text]
value:nil] build]];
}
按鈕點擊還好,但要追蹤畫面時就很難看:
- (void)viewDidAppear:(BOOL)animated {
[super viewDidAppear:animated];
id<GAITracker> tracker = [[GAI sharedInstance] defaultTracker];
[tracker set:kGAIScreenName value:@"Stopwatch"];
[tracker send:[[GAIDictionaryBuilder createAppView] build]];
}
對多數有經驗的 iOS 工程師而言,這不是好程式碼——我們把不屬於 view controller 職責的統計邏輯塞了進去。即使你把邏輯藏到別的物件,問題依然存在:最後你還是在 viewDidAppear: 之後插入了程式碼。
改用 AOP 的話,可以在 viewDidAppear: 上掛切面來追蹤畫面,也能對其他感興趣的方法(例如按下按鈕時呼叫的 IBAction)掛上事件追蹤。這種做法簡潔且無侵入性:view controller 不會被外來程式碼污染;所有切面集中在一個 SPOC 檔(single point of customization)中;SPOC 應在 App 啟動時套用;若 SPOC 中有任何 selector 或類別無法識別,App 會在啟動時崩潰(對我們而言這是好事,能及早發現問題)。統計團隊提供的追蹤文件通常可以直接映射成一個 SPOC 檔;追蹤邏輯抽象化之後,要換到別的統計框架也很容易。
NSDictionary *analyticsConfiguration() {
return @{
@"trackedScreens" : @[
@{ @"class" : @"ZOCMainViewController", @"label" : @"Main screen" }
],
@"trackedEvents" : @[
@{ @"class" : @"ZOCMainViewController", @"selector" : @"loginViewFetchedUserInfo:user:", @"label" : @"Login with Facebook" },
@{ @"class" : @"ZOCMainViewController", @"selector" : @"shareButtonPressed:", @"label" : @"Share button" }
]
};
}
- (void)setupWithConfiguration:(NSDictionary *)configuration {
for (NSDictionary *trackedScreen in configuration[@"trackedScreens"]) {
Class clazz = NSClassFromString(trackedScreen[@"class"]);
[clazz aspect_hookSelector:@selector(viewDidAppear:)
withOptions:AspectPositionAfter
usingBlock:^(id aspectInfo) {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[tracker trackScreenHitWithName:trackedScreen[@"label"]];
});
}
error:nil];
}
for (NSDictionary *trackedEvent in configuration[@"trackedEvents"]) {
Class clazz = NSClassFromString(trackedEvent[@"class"]);
SEL selektor = NSSelectorFromString(trackedEvent[@"selector"]);
[clazz aspect_hookSelector:selektor
withOptions:AspectPositionAfter
usingBlock:^(id aspectInfo) {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[tracker trackEvent:trackedEvent[@"label"]];
});
}
error:nil];
}
}