iOS 編程,本質上就是 Cocoa 編程。因此必須熟悉 Cocoa,知道它是什麼、能做什麼,以及你該如何與它「交流」。
Cocoa 是一個龐大的 Framework,被分割成若干較小的 Framework。任何 iOS 編程人員都需要花費一定時間才能真正熟練掌握 Cocoa。
Cocoa 中包含一些主要的規則和組件,最好以它們為主線來學習 Cocoa。
Cocoa 大部分類都是用 OC 寫的,雖然 OC 類和 Swift 類能相互轉換,但 Swift 中的 Enum 和 Struct 與 OC 中的並不兼容。不過,一些重要的 Swift 對象都能橋接到 Cocoa 類。
本章主要介紹 Cocoa 的組織方式(即它的組成),然後說明一些常用類的用法,最後介紹 NSObject 類。
Swift 中自定義類的方式有多種:繼承、類擴展、協議。
當 Cocoa 提供的類無法滿足需求時,我們可以進行自定義。
但首先要對 Cocoa 中的類有全面了解,因為有的功能並不是沒有,而只是你沒找到,所以請熟悉相關的類文檔。
有些類註定會被繼承,比如 UIViewController 類。
另一個例子是 UIView,許多類都繼承自它,比如 UIButton、UITextField 等。
如果要添加額外的繪制行為,可以重寫 drawRect: 方法。過程是先繼承 UIView,然後在子類中實現 drawRect: 方法即可。
比如要在 window 中繪制一條水平線,由於 Cocoa 中沒有繪制水平線的類,那就可以自定義一個 UIView 的子類,讓它來繪制這條線。
方法如下:
新建工程並新建一個類,命名為 MyHorizontal,讓它繼承自 UIView。修改 MyHorizontal.swift 如下所示:class MyHorizontal: UIView { required init?(coder aDecoder: NSCoder) { super.init(coder: aDecoder) self.backgroundColor = UIColor.clearColor() } override func drawRect(rect: CGRect) { let c = UIGraphicsGetCurrentContext() CGContextMoveToPoint(c, 0, 0) CGContextAddLineToPoint(c, self.bounds.size.width, 0) CGContextStrokePath(c) } }3. 在 storyboard 中 VC 控制的 scene 裡的 View 內再添加一個 view,並把這個 view 的類型修改為 MyHorizontal。
4. 運行程序,可以看到需要的線已經畫出來了,如下圖所示:
上述代碼中,繼承自 UIView 的類繪制了一條水平線。由於 UIView 本身沒有其他繪制行為,故在
drawRect:方法中沒有調用super.drawRect:。
UIView 的子類 UILabel 中有兩個方法:drawTextInRect: 和 textRectForBounds:limitedToNumberOfLines:。如果要自定義 Label 的繪制行為,可以重寫這兩個方法。比如下面讓一個 UILabel 繪製帶邊框的文本:
class MyBoundedLabel: UILabel { override func drawRect(rect: CGRect) { let context = UIGraphicsGetCurrentContext()! CGContextStrokeRect(context, CGRectInset(self.bounds, 1.0, 1.0)) super.drawTextInRect(CGRectInset(rect, 5.0, 5.0)) } }3. 在 View 中添加一個 Label 控件,並把它的類型修改為 MyBoundedLabel,運行程序如下所示:
實際工作中,用繼承來自定義子類的情況並不多見(在 Cocoa 框架內),雖然有時用繼承的確比較方便。
原則:除非 Cocoa 要求你用繼承來自定義行為,否則不應該使用。
絕大多數 Cocoa Touch 類都不需要繼承(有些在文檔中明確表示不能繼承),因為有 Delegation(委托)的存在。
推薦使用委托來添加自定義行為。
比如 UIApplication 對象,它的許多行為都轉交給 AppDelegate 對象來代理。而 AppDelegate 類並不是繼承自 UIApplication 類,而是接受了 UIApplicationDelegate 協議。
Category 在 OC 中表示類擴展(具名類擴展),而 Cocoa 中大量使用 Category 來組織類,它相當於 Swift 中的 Extension。
利用 Extension,可以把類方法或對象方法注入到類中。
Swift 中廣泛使用 extension,原因有兩點:對類進行合理組織;自定義 Cocoa 類。
比如在 Swift.h 頭文件中,就用了許多 Extension 來添加屬性或行為。
頭文件中 Array 的 Extension:
extension Array : CustomStringConvertible, CustomDebugStringConvertible { /// A textual representation of `self`. public var description: String { get } /// A textual representation of `self`, suitable for debugging. public var debugDescription: String { get } } extension Array { /// Call `body(p)`, where `p` is a pointer to the `Array`'s /// contiguous storage. If no such storage exists, it is first created. /// /// Often, the optimizer can eliminate bounds checks within an /// array algorithm, but when that fails, invoking the /// same algorithm on `body`'s argument lets you trade safety for /// speed. public func withUnsafeBufferPointer(@noescape body: (UnsafeBufferPointer) throws -> R) rethrows -> R /// Call `body(p)`, where `p` is a pointer to the `Array`'s /// mutable contiguous storage. If no such storage exists, it is first created. /// /// Often, the optimizer can eliminate bounds- and uniqueness-checks /// within an array algorithm, but when that fails, invoking the /// same algorithm on `body`'s argument lets you trade safety for /// speed. /// /// - Warning: Do not rely on anything about `self` (the `Array` /// that is the target of this method) during the execution of /// `body`: it may not appear to have its correct value. Instead, /// use only the `UnsafeMutableBufferPointer` argument to `body`. public mutating func withUnsafeMutableBufferPointer(@noescape body: (inout UnsafeMutableBufferPointer) throws -> R) rethrows -> R }
代碼中的 Extension 屬於協議擴展。
從功能上講,協議擴展完全是可有可無的,因為這些內容本可以全部寫進 Array 類中。但為了便於理解,這裡按邏輯功能把類的方法或屬性劃分成一個個獨立的擴展。
Swift 中允許定義全局函數,這樣做本身沒錯,但卻不滿足 OO 編程對封裝的要求,因此更好的方式是把函數寫到類裡去。
假如僅僅為了添加幾個方法就去繼承一個龐大的類,這樣往往得不償失,而且很可能無法幫助你完成想做的任務(比如想添加一個能處理多種類型的函數,若用繼承,這個方法就只能處理該類對象,其他類對象又得重新定義方法)。此外,Extension 還可以用在 Enum、Struct 上,而繼承只能用在 Class 上。
而且還有個好處:如果把某個方法用 Extension 插入到類中,該類的全部子類都會自動獲得這個方法。
比如要讓 UIButton 和 UIBarButton 都具備某個行為,可以聲明一個具有該行為的 Protocol,然後在 Protocol 的 extension 中實現該方法,那麼這兩個類只需接受 Protocol,就自動擁有了該方法,而無需各自實現。這樣的 Extension 就是協議擴展。
protocol ButtonLike {//協議聲明 func behaveLikeAButton() } extension ButtonLike {//協議extension,即實現 func behaveLikeAButton { //... } //在使用時,只需聲明即可, 用協議擴展類. extension UIButton : ButtonLike {} extension UIBarButton : ButtonLike{} }
這個辦法可以用於為若干類統一添加行為。
總結一下添加自定義行為的兩個辦法:
定義某個類的 Extension:
extension UIViewController { //直接擴展類添加方法 func saySomething { print("hello") } } //... //使用時,比如在ViewController的viewDidLoad方法中: self.saySomething() //輸出hello
協議擴展
protocol someBehavior { func saySomething() } extension someBehavior { //這裡理解為擴展該協議,實際和擴展類的道理一樣,反正extension中必須有實現 //找到了,如果想分別定義不同行為,又想接受統一個protocol,則這裡留空,然後在每個聲明中去實現. func saySomething() { print("good morning") } } //... //使用時,先這樣聲明,這個語法必須記住: extension UIViewController : someBehavior {} //聲明這個類接受協議擴展 extension UIView : someBehavior {} //... //然後就可以使用了,比如在UIViewController的子類ViewController中: self.saySomething() //輸出good morning
Cocoa 使用 Category 來組織類,把類按功能分割成若干組成部分,每個部分對應一個 Category,並且每個 Category 對應一個頭文件。
這種方式會給文檔查詢帶來影響。比如文檔中對 NSString 類的聲明只提到三個文件:NSString.h、NSPathUtilities.h 和 NSURL.h,卻沒有提到 NSStringDrawing.h(它被放在了 NSString UIKit Additions 中),不得不說這是 Cocoa 文檔的一個瑕疵。
OC 的 Protocol 和 Swift 的 Protocol 可以相互轉化,而且在 Swift 中被標記 @objc 的 protocol 可以被 OC 使用。
例如 Cocoa 中對象復制時,有的對象可被復制,有的卻不能,這是因為 Cocoa 定義了一個復制對象協議:NSCopying。
NSCopying 在 NSObject.h 中實現,但 NSObject 本身並沒有接受這個協議。
接受這個協議的類才能使用它:
let s = "hello".copyWithZone(nil)
比如遵守某個協議的屬性:
weak var dataSource : UITableViewDataSource?
意思是:不管 dataSource 是什麼類型,只要它是接受 UITableViewDataSource 協議的類型對象,就可以賦值給 dataSource 屬性。這裡的「接受」是指類聲明中包含該協議,並且類中實現了 required 方法。
協議的另一個典型場景:代理協議。
比如在 UIApplication 中有一個屬性:
unowned(unsafe) var delegate : UIApplicationDelegate?
這個屬性用於指定它的代理對象。
Cocoa 中的協議都有其單獨文檔,列出協議內的方法。比如上面代碼中,UIApplicationDelegate 就是一個協議。
當一個類接受某協議之後,它的行為變得更多了。這時不僅要關注類自身的行為,還要關注協議中聲明的行為,甚至還要關注其父類的行為,以及父類所接受的協議規定的額外行為……
Informal Protocol 並非真正的協議,它是給編譯器提供方法聲明的一種途徑,好讓編譯器不再抱怨。
實現 Informal Protocol 的兩種途徑:
在 NSObject 上定義一個 Category,這樣 Cocoa 中所有對象都能夠接收滿足條件的消息;
定義一個協議,不是讓某個類去接受,而是讓 id(AnyObject)類型對象接受,這樣可以清除所有可能的編譯錯誤(指發送協議方法時)。
這種技術以前用得很多,不過自從 protocol 有了 optional 方法之後,它就被替代了。但在 Cocoa 中仍有少部分地方在使用 Informal protocol。
所有的 OC 協議,以及在 Swift 中用 @objc 聲明的協議,都可以擁有 Optional 方法。
當對象接收一個它無法處理的消息時(它裡面沒有這個方法),就會出錯並拋出異常。
但如果類中有這個方法的聲明,就表明這個類有處理這個消息的能力,只是還沒實現,這樣就能避免異常(這正是 Informal protocol 的用途,也即 Optional 的作用)。
OC 中調用 respondsToSelector: 來判斷某對象能否響應某方法,Swift 也使用類似方法。
比如下面的協議:
@objc protocol Flier { optional var song : String {get} //只讀屬性 optional func sing() }
假如某類型接受該協議,向這種類型的對象發送 sing?() 消息,系統會自動調用 respondsToSelector: 判斷對象能否處理該消息,然後再決定是否把消息發送給對象(這樣便不會出現異常)。
使用 Optional 方法時會調用 respondsToSelector:,這会带来一部分額外開銷。
在正式編程之前,需要了解一些常用的類,詳見 Foundation Framework Reference。
NSRange:
它是一個 C 結構體,具有兩個屬性:location 和 length。比如 location 是 1、length 是 2,表示從下標 1 開始、長度為 2 的範圍。
使用 NSMakeRange 可以創建 NSRange。
Swift 裡有 Range 結構體,可以將 NSRange 轉換為 Swift 的 Range,方法是:
let r = NSRange().toRange() //可選類型的Range.
NSNotFound 是一個整型常量,用於指示未找到的情況。
許多查找方法都會返回 NSNotFound,比如下面這個:
let arr = ["hey"] as NSArray let ix = arr.indexOfObject("he") if ix == NSNotFound { print("it's not here.") }
如果找到的話,indexOf 方法會返回一個可選值包裝的 Int,否則就是 nil。
如果返回的是 NSRange,那麼它的 location 值就會是 NSNotFound。
Swift 可以自動處理轉換問題,讓你不必擔心與 NSNotFound 比較會出錯。
比如 NSString 的 rangeOfString: 返回值是 NSRange,如果其中 location 的值是 NSNotFound,那麼對應的 Swift Range 值就是 nil:
let s = NSString(string: "hello world") let y = s.rangeOfString("good").toRange() //y的值為nil.
這樣的好處是:如果你需要一個 Swift 的 Range,可以用 NSRange 轉換出來;如果你需要一個 NSRange,那直接使用即可,它能直接與 Cocoa 交互。
let s = "hello" as NSSring let r = s.indexOfString("ha") //這樣r即為一個NSRange if r.location == NSNotFound { print("it wasn't found") }
NSString 是 Cocoa 中的字符串,它被橋接到 Swift 的 String,二者可以自動轉換。
你可以把 Swift 的 String 作為參數傳給需要 NSString 的函數,也可以在 String 上直接使用 NSString 的方法等等。
比如
let s = "hello" let s2 = s.capitalizedString //capitalizedString 返回NSString,但s2為HELLO,是Swift的String
轉換過程是:在 s 上調用 capitalizedString: 方法時,先把它自動轉換為 NSString,然後調用方法,方法返回一個 NSString,再被自動轉換成 String 賦值給 s2。
這樣的好處是可以直接在 String 上使用 NSString 方法,但如果你沒有 import Foundation,就會出錯。
但有時轉換無法自動完成,比如:
let s = "my" let s2 = s.stringByAppendingPathExtension("text") //報錯 let s3 = s.substringToIndex(1) //報錯
解決辦法都是先把 s 轉換為 NSString 再調用即可:
let s2 = (s as NSString).stringByAppendingPathExtension("text")
具體原因是 NSString 和 String 在元素的表示上存在差異,詳見蘋果 String Programming Guide。
還有一個注意點:NSString 是不可變的,要使用它的可變版本,則用 NSMutableString。
比如:
let s3 = "abcdefg" //s3是Swift的String let s4 = NSMutableString(string: s3) //s4是NSMutableString s4.deleteCharactersInRange(NSMakeRange(1, 3)) let s5 = (s4 as String) + "hh" //s5 is a Swift String
在以後的編程中,你經常需要在 String 和 NSString 的「連接橋」上來回穿梭,但多數情況是在 NSString 這邊,因為許多優秀的方法都在 Cocoa 裡面,比如字符串搜索:
NSString 有許多類似 rangeOfString: 的方法,比如忽略大小寫、從尾部搜索等。當你連自己要搜索什麼都無法確定時,可以用一定的結構來描述它,比如使用 NSScanner;指定選項 .RegularExpressionSearch 支持以正則表達式搜索,另外正則表達式也可以是單獨的類 NSRegularExpression,在其中使用 NSTextCheckingResult 來描述匹配結果。還有支持複雜文本自動分析的 NSDataDetector,它是 NSRegularExpression 的子類,可用於高效搜索如 URL 或電話號碼;以及用於文本語法分析的 NSLinguisticTagger。
下面的例子嘗試把文本中所有的 "hell" 替換成 "heaven",但不想替換 hello 裡的 hell:
let s = NSMutableString(string: "hello world, go to hell") let r = try! NSRegularExpression(pattern: "\\bhell\\b", options: .CaseInsensitive) r.replaceMatchesInString(s, options: [], range: NSMakeRange(0, s.length), withTemplate: "heaven") // s 現在變成了 "hello world, go to heaven"
NSString 也可以很方便地表示文件路徑,它經常和 NSURL 結合使用。
NSString 和其他一些類都提供了讀寫文件的方法,文件既可以用 NSString 表示的檔案路徑指定,也可以用 NSURL 指定。
NSString 本身不含文字樣式信息,如果想使用文字樣式,則要用到 NSAttributedString、NSParagraphStyle、NSMutableParagraphStyle,這些類允許自定義文本或段落風格,同時內置的 UI 對象可以顯示帶風格的文本。
NSString 以及 NSAttributedString 上的 NSStringDrawing 擴展支持字符串繪制,詳見 String UIKit Additions Reference 和 NSAttributedString UIKit Additions Reference。
通俗地說,NSDate 就是表示日期和時間,內部以秒(NSTimeInterval)來表示距某個參考日期的間隔。
調用 NSDate 的構造函數構造出來的 NSDate 對象表示當前日期和時間:NSDate()
許多日期操作都涉及 NSDateComponents 類的使用,如果想在 NSDate 和 NSDateComponents 之間轉換,需要用 NSCalendar 作為中間媒介。
一般使用日歷來構造 NSDate:
let greg = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)! let comp = NSDateComponents() comp.year = 2016 comp.month = 8 comp.day = 10 comp.hour = 15 let d = greg.dateFromComponents(comp) //上面的代碼中先構造一個日歷greg,然後構造一個日期組件comp,設置日期組件,再使用greg的dateFromComponents方法來獲得NSDate
同時,如果想對日期進行計算,則可以用 NSDateComponents:
let d = NSDate() let comp = NSDateComponents() comp.month = 1 let greg = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)! let d2 = greg.dateByAddingComponents(comp, toDate: d, options: [])
代碼中先構造當前日期,然後構造一個只設置月份的日期組件,再以 NSCalendar 為中介,在當前日期上加一個日期組件的值,得到日期 d2。
可以將日期表示為字符串,默認是 0 時區的。如果想獲得當前時區中的時間,可以用如下方式:
print(d) print(d.descriptionWithLocale(NSLocal.currentLocale()))
兩條語句的輸出結果為:
2016-07-21 08:21:55 +0000 Thursday, July 21, 2016 at 4:21:55 PM China Standard Time
為了解析日期字符串,可以使用 NSDateFormatter,它使用類似 NSLog 的格式控制字符:
let df = NSDateFormatter() let format = NSDateFormatter.dateFormatFromTemplate("dMMMMyyyyhmmaz", options: 0, locale: NSLocale.currentLocale()) df.dateFormat = format let s = df.stringFromDate(NSDate())
代碼中創建一個 NSDateFormatter 對象 df,用於解析日期字符串;然後構造一個自定義的 format,用來設置 df 的格式;最後調用 df.stringFromDate,即可得到指定格式的字符串。
如果想逆向解析這個字符串,只需用相同的 format 設置,然後用 NSDateFormatter 的 dateFromString 方法解析即可。
NSNumber 是一個包含數值的對象,裡面的數值可以是任何 OC 原子數值類型。由於 OC 原子類型並非對象,所以這樣的數值不能用在需要對象的場合中。
但利用它,可以將 Swift 中的數值對象轉換為原子類型數值。
Swift 中為了避免用戶直接接觸 NSNumber,將數值對象與 OC 的數值進行了橋接:
如果我們需要的是原子數值(即不是對象),則將 Swift 中的數值(對象)轉換為原子數值;
如果我們需要的是數值對象,則將 Swift 的數值對象自動轉換為 NSNumber。可以自動轉換的類型有 Int、UInt、Float、Double、Bool,下面就是自動橋接轉換的例子:
let ud = NSUserDefaults.standardUserDefaults() let i = 0 ud.setInteger(i, forKey: "Score") ud.setObject(i, forKey: "Score")
只看第 3 行和第 4 行:這兩行的 i 就是不同方式的轉換,i 是 Swift 數值對象,它在第 3 行被轉換為一個原子數值,而在第 4 行被轉換為 NSNumber 對象。
如果想在 Swift 中進行顯式轉換,可以用下面的方式:
let n = 0 as NSNumber //顯式類型轉換 let u = NSNumber(float:0) //直接使用NSNumber構造方法
值從 OC 返回 Swift 時,大多數情況返回的都是 AnyObject,此時需要進行類型轉換。
NSNumber 僅僅作為一個數值的容器,如果需要裡面的數值,還需要手動把數值「解壓」出來。
NSNumber 的子類 NSDecimalNumber 支持計算,但僅限於兩個 NSDecimalNumber 之間,比如:
let dec1 = NSDecimalNumber(float: 4.0) let dec2 = NSDecimalNumber(float: 5.0) let sum = dec1.decimalNumberByAdding(dec2)
NSDecimalNumber 經常被用在取整上,因為它提供了許多方便的方法。
NSDecimalNumber 內部實際包含一個 NSDecimal 結構體(對應 decimalValue 屬性),這是一個 C 結構體。NSDecimal 結構體的函數比 NSDecimalNumber 的方法速度更快。
NSValue 是 NSNumber 的父類,用於包裝非數值類型的 C 值,比如結構體。
在 Swift 中無法直接使用 C 的結構體,利用 NSValue 就能解決這一問題。
我們經常用 NSValue 來包裝以及解包 CGPoint、CGRect、CGSize 等結構體,以及 NSRange、CATransform3D、CMTime 等。
通常不需要手動把 C 結構體保存在 NSValue 中,但如果你想這麼做的話也是可以的。因為 Swift 不會自動把 C 結構體裝進 NSValue,需要你自己手動完成。
另外,我們可以把 CGPoint 裝進 Swift 數組中,因為 CGPoint 是 Swift 結構體(也是對象),而 Swift 數組可以存放任何對象。但在 OC 中卻不行,因為 OC 數組只能存放對象,所以在 OC 中得先把 CGPoint 裝進 NSValue,再放入數組中。
NSData 實際上就是一串字節,或者說它是一個緩沖池、一塊內存區域。
NSData 是不可變的,不過它有可變子類 NSMutableData。
實際工作中有兩大情況需要使用 NSData:
當從網絡下載數據時。
例如 NSURLConnection 或 NSURLSession 可以把任何從網絡獲取的數據保存在 NSData 中。假設獲取的是一些字符串,那麼只要指定正確的解碼方式,就可以把字符串從 NSData 中解析出來。
當把對象保存到文件或用戶配置(NSUserDefaults)中時。
例如,你無法直接把一個 UIColor 保存到用戶配置中,當用戶選擇一個顏色並保存時,得先把 UIColor 轉換成 NSData(使用 NSKeyedArchiver),然後再保存:
let ud = NSUserDefaults.standardUserDefaults() let c = UIColor.blueColor() let cdata = NSKeyedArchiver.archivedDataWithRootObject(c) ud.setObject(cdata, forKey: "myColor")
代碼中先獲得用戶配置 ud,然後構造一個 cdata(從顏色對象 c 而來),它是 NSData 類型的,構造用的是 NSKeyedArchiver 的 archivedDataWithRootObject: 方法,最後把這個 cdata 保存到 ud 中。
在 Swift 中,操作符可以在類中覆蓋定義(類似 C++ 的運算符重載),並使用 infix、postfix、prefix 分別表示二元、一元前綴、一元後綴運算符:
infix operator + { //.... }
但 OC 中運算符不支持重載。要比較兩個對象,比如判等,需要覆蓋實現 isEqual 對象方法,該方法從 NSObject 繼承而來。
而 Swift 中把 NSObject 類或其子類看作可比較的,比較時會自動把 "==" 操作隱式轉換成 isEqual 方法的調用。
let n1 = NSNumber(integer: 1) let n2 = NSNumber(integer: 2) let n3 = NSNumber(integer: 3) let ok = n2 == 2 let ok2 = n2 == NSNumber(integer: 2) let ix = [n1, n2, n3].indexOf(2)
上面代碼無錯的原因有兩點:Swift 自動把數值包裝成 NSNumber 對象;Swift 自動把 "==" 操作符轉換成調用 isEqual 方法。
NSNumber 裡面已經實現了 isEqual,所以可以直接使用 "==" 操作符。
但如果某個 NSObject 子類沒有實現 isEqual,就會執行 NSObject 中的 isEqual,即比較兩個對象是否是同一個,類似於 Swift 中的 "===" 操作符。
class Dog : NSObject { var name : String init(name:String) { self.name = name } } let d1 = Dog(name: "Fido") let d2 = Dog(name: "Fido") let ok = d1 == d2
代碼中的 Dog 類繼承自 NSObject,但沒有實現 isEqual,則判等為假。
OC 對象更多地是使用比較函數來比較,如 NSNumber 的 isEqualToNumber: 等。但這些類上同樣實現了 isEqual,在 Swift 中使用 "==" 肯定比用 isEqualToNumber 方法更簡便。
OC 中對象的大小比較則要看具體類裡是否有相應實現。標準的比較方法是 compare:,返回 NSComparisonResult 對象,它有三種結果:
.OrderedAscending 升序
即接收對象比參數對象小。
.OrderedSame 相等
即接收對象和參數對象相等。
.OrderedDescending 降序
即接收對象比參數對象大。
Swift 不會自動調用 compare 方法,也就是說如果代碼中出現兩個 NSObject 或其子類對象比較大小的情況,直接使用 ">" 這類比較操作符是不行的。比如下面的代碼會出錯:
let n1 = NSNumber(integer: 1) let n2 = NSNumber(integer: 2) let ok = n1 > n2 //錯
此時需要顯式調用 compare 方法:
let n1 = NSNumber(integer: 1) let n2 = NSNumber(integer: 2) let ok = n1.compare(n2) == .OrderedAscending //true
代碼中 n1 為 1、n2 為 2,n1 的 compare 方法返回 n1 小於 n2 對應的 NSComparisonResult,即 .OrderedAscending,故 ok 值為 true。
NSIndexSet 是數值集合,主要用於表示關系集合中元素的下標。
比如想同時訪問數組中多個對象,可以先把這些對象的下標全部存放到一個 NSIndexSet 中。
可以傳遞一個 NSIndexSet 給 UITableView,指示在哪些 section 中插入或刪除元素。
假設需要訪問數組中下標為 1、2、3、4、8、9、10 的元素,可以先把它們存放在 NSIndexSet 對象中。
同樣,NSIndexSet 是不可變的,它有一個可變子類 NSMutableIndexSet。
可以傳遞一個 NSRange 來構造 NSIndexSet,但當下標情況比較複雜時,可以使用 NSMutableIndexSet,利用 addIndexes 添加 NSRange 進去:
let arr = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 11] let ixs = NSMutableIndexSet() ixs.addIndexesInRange(NSRange(1...4)) ixs.addIndexesInRange(NSRange(8...9)) let arr2 = (arr as NSArray).objectsAtIndexes(ixs) //arr2 為[8, 7, 6, 5, 1, 0]
代碼中先構造一個 NSMutableIndexSet 對象 ixs,然後往裡附加兩個範圍,之後通過 ixs 指定的下標構造出新數組。
可以使用 for...in 遍歷 NSIndexSet 中存放的下標,也可以使用 enumerateIndexesUsingBlock: 或 enumerateRangesUsingBlock: 及其變體來遍歷。
NSArray 是 OC 數組類型,功能上和 Swift 數組類似,並且 NSArray 和 Swift 數組也進行了橋接。
與 Swift 數組相比,NSArray 裡面必須存放對象,並且對象類型可以不一致。
NSArray 同 Swift 數組相互轉換的方法詳見書上。
TIP:在 iOS 9 中,如果 NSArray 裡保存的對象都是同一種類型,則可以在 OC 中標明該數組的類型,這樣 Swift 中就能直接讀取該數組類型。通過這樣,從 OC 橋接回 Swift 就不會再得到一個 [AnyObject],而是一個實在的數組。這同樣適用於 NSSet,以及少部分 NSDictionary。
NSArray 的長度在 count 屬性中,可以通過 objectAtIndex 獲取裡面的元素。下標從 0 開始,故最後一個元素的下標為 count - 1。
除了 objectAtIndex,也可以直接使用下標操作符,即用諸如 "[0]" 獲取指定下標的元素。
NSArray 能夠使用下標操作符,並非因為它橋接到了 Swift,而是它裡面實現了 objectAtIndexedSubscript: 方法。
可以使用 indexOfObject: 或 indexOfObjectIdenticalTo: 來查找元素。前者調用該類中定義的 isEqual,而後者使用的是類似 Swift 中 "===" 的方式。前面說過,如果沒找到元素,返回的就是 NSNotFound。
NSArray 是不可變的,即不能改變它裡面保存的元素,但對於每個元素內部的修改,NSArray 是沒有限制的。
NSArray 有可變子類 NSMutableArray,使用它可以動態增減元素。
Swift 的 Array 沒有橋接到 NSMutableArray。
如果從 OC 回到 Swift,NSMutableArray 也是一個 [AnyObject],但它不能直接轉換成 Swift 的 Array,需要先把它轉換成 NSArray,然後再轉換成對應類型的 Swift Array:
let marr = NSMutableArray() marr.addObject(1) //數值先自動轉存成了NSNumber以存放到可變數組中 marr.addObject(2) let arr = marr as NSArray as! [Int] //先轉換成NSArray,再轉換成對應類型的Swift數組.
可以使用 block 在數組中查找或過濾元素,還可以對數組排序,只需指定排序規則。對於可變數組而言,可以直接進行排序。當然在 Swift 數組中可以很方便實現這些操作,但了解如何在 Cocoa 中進行同樣重要:
let pep = ["marry", "joe", "mood"] as NSArray let ems = pep.objectsAtIndexes(pep.indexesOfObjectsPassingTest({ (obj, idx, stop) -> Bool in return (obj as! NSString).rangeOfString("m", options: .CaseInsensitiveSearch).location == 0 })) let s = ems as! [String] print(s) //["marry", "mood"]
上面就是過濾並篩選之後輸出數組的例子。
NSDictionary 是 OC 中的字典類型,功能上和 Swift 中的字典類似,它們二者也已被橋接。
NSDictionary 的鍵和值都必須是對象,鍵值對類型不必統一,這和 Swift 不一樣。作為鍵的對象必須接受 NSCopying 協議,並且可散列。
NSDictionary 和 Swift 字典的橋接及轉換詳見書上。
NSDictionary 是不可變的,它有可變子類 NSMutableDictionary,並且 Swift 字典沒有橋接到 NSMutableDictionary。
要構造一個可變字典,可以直接使用它的構造方法:init() 或 init(dictionary:)。
NSDictionary 的鍵可以用 isEqual 來判別比較。如果你往可變字典裡添加一個鍵值對,若該鍵在字典中還不存在,就直接把這個鍵值對加進去;但如果鍵已存在,就會用新值覆蓋對應鍵的值,這和 Swift 字典的行為類似。
字典最基本的用法是通過鍵來取值,比如使用 objectForKey: 方法:如果 key 存在,返回對應的值對象;若不存在,則返回 nil。但在 OC 中,nil 並非對象,因此不能作為 NSDictionary 的值對象。
總的來說,因為 Cocoa 大部分是 OC 寫的,所以需要遵守一些 OC 規則。
Swift 處理 objectForKey 返回值的辦法是把它作為一個 AnyObject?,即一個包裝任意類型的可選值。
在 NSDictionary 或 NSMutableDictionary 中都可以使用下標來訪問鍵對應的值,道理和在 NSArray 中使用下標類似。NSDictionary 中實現了 objectForKeyedSubscript: 方法,Swift 把它等價為下標的 getter;另外在 NSMutableDictionary 中還實現了 setObject:forKeyedSubscript: 方法,Swift 把它等價為對下標的 setter。
可以獲取 NSDictionary 中全部鍵的列表或全部值的列表,或按值排序的鍵值對列表;也可以使用 Block 來遍歷鍵值對,甚至可以通過測試來過濾 NSDictionary 中的特定值。
NSSet 是一個無關的互異對象集合。它裡面的對象都是互異的,即任意兩個對象用 isEqual 比較都不會返回 true;「無關」則是指兩個對象之間不存在邏輯關系。
在 NSSet 中的查詢操作比數組中的查詢效率更高,而且對於一個 Set,可以查詢它是否是某 Set 的子集,或它與另一 Set 的交集。
使用 for...in 遍歷 Set,當然遍歷出來的內容是無序的。
可以過濾一個 Set,方式與過濾 Array 類似。
可以看出,Set 上的大部分操作都和數組類似,當然在 Set 上無法進行需要元素有序為前提的操作,比如下標操作。
可以使用 NSOrderedSet 來構造一個有序集合。NSOrderedSet 和數組十分相似,操作它的方法也和數組類似,比如可以用下標訪問其中元素。
NSOrderedSet 比數組更具優勢,比如在查詢效率上,另外它可以直接進行兩個 NSOrderedSet 之間的並集、交集、差集操作。所以在條件允許的情況下,可以盡量使用 NSOrderedSet。
TIP:把一個數組傳給 NSOrderedSet,意味著順序仍然得以維護,但只有互異的元素會被傳入集合中(即自動進行了一次去重操作,順序仍和數組中的一致)。
NSSet 是不可變的,但可以通過從其他 NSSet 添加或刪除元素得到新的 NSSet。
NSSet 有可變子類 NSMutableSet。
當然 NSOrderedSet 也有其可變子類 NSMutableOrderedSet(使用它可以用下標訪問元素,因為其中實現了 setObject:atIndexedSubscript: 方法)。
往 Set 中加入已存在的元素不會出錯,只是添加操作不會發生。
NSMutableSet 還有一個子類 NSCountedSet,這個子類是可變的,並且元素允許重復,它常被稱為 bag。
NSCountedSet 的實現其實就是一個 Set 外加記錄每個元素出現次數的計數器。
Swift 中的 Set 被橋接到 NSSet。但 NSSet 中元素必須是對象(類對象或類的實例對象),而且元素類型不必統一。
NSMutableSet、NSOrderedSet、NSMutableOrderedSet、NSCountedSet 都沒有被橋接到 Swift。
但可以先把 NSMutableSet 向上轉換為 NSSet,然後再轉換為 Swift 的 Set(和 NSMutableArray 的轉換類似)。
NSOrderedSet 從表面上看和 Swift 的數組或 Set 並無二致,因為它們的行為基本相同,但建議不要輕易把 NSCountedSet 或 NSOrderedSet 轉換到 Swift 中,能讓它們留在 OC 世界就盡量留著。
NSNull 的作用就是提供一個指向單例(NSNull 對象)的指針,使用 NSNull() 獲取該單例。
某些情況下需要 OC 對象,但又不允許使用 nil,此時就用 NSNull 來代表 nil。
比如在 OC 的任何一種集合中都無法添加值為 nil 的元素,因為 nil 本來就不是對象,這時為了代表 nil,就用 NSNull() 來添加「意義上是 nil 的元素」對象。
可以在 NSNull 單例對象上使用 "==" 操作符,它會自動調用 NSObject 裡面的 isEqual 方法,即判斷兩個對象指針是否相等。
Cocoa 中通常都是「一個不可變類擁有一個可變子類」的組織方式。不可變類和可變類,就好比 Swift 中 let 和 var 的區別。
比如使用 NSArray,就和在 Swift 中用 let 定義一個數組的方式相同:用戶不能向這種數組添加元素、刪除元素或替換元素,但如果獲取到其中的元素,在元素身上進行的修改,數組是無權控制的。
而 Cocoa 框架採用不可變/可變這樣的類組織,目的就是為了防止未授權的訪問。比如一個數組,可以先在內部暫時使用它的可變子類,當需要傳遞出去時,就使用不可變的數組,這樣可以防止外部的修改。
而 Swift 不存在這樣的情況,因為內部的對象如 String、Array 等,修改它們的唯一方式就是創建副本並賦值新修改的副本,這樣就能被 setter observer 自動檢測到。所以 Swift 中不用擔心修改不被察覺的問題。
用戶可以使用 copy 或 mutableCopy 生成某個對象的不可變或可變副本,但這樣的方式沒有任何方便可言,因為這些副本是 AnyObject 的,需要進行類型轉換。
Warning:這種不可變/可變類組織方式,實際是由類簇(class cluster)實現的,即用戶使用的類只是一個接口,而真正實現的類被隱藏在接口層次的下面。你不必去關心這些作為接口的類下面的實現類細節,想關心也關心不了。
Property List 實際上是字符串(XML),用於存放數據。
只有如下幾種類才可以被轉換為 Property List:NSString、NSData、NSArray、NSDictionary。
NSArray 或 NSDictionary 轉換成 Property List 的條件是:包含的對象必須都是可轉換為 Property List 的類型(這也是為什麼在 UIColor 存儲的例子裡,UIColor 必須先轉換為 NSData 然後才可以存放到 User Default 中,因為 User Default 也是 Property List)。
Property List 的一個重要作用是把數據存儲到文件中,當需要這些數據時,還可以再次重構到某對象中。
NSArray 和 NSDictionary 中的 writeToFile:atomically: 和 writeToURL:atomically: 方法可以方便地實現 Property List 的生成和存放,只需給出文件路徑或 URL 即可。這兩個類也提供了通過文件生成數組或字典的方法。
NSData 和 NSNumber 中也提供了文件讀寫方法,只是這些方法把對象數據直接寫入文件(即寫入的不是 XML),而非生成 property list 再寫入文件。
當由 property list 文件生成對應數組或字典對象時,內部包含的字符串或數據都是不可變的。
如果想讓它們可變,或者想把一個 property list 對應的對象轉換為另一類型的 property list(比如字典 property list 和數組 property list 的轉換),可以使用 NSPropertyListSerialization 類型,詳見蘋果 Property List Programming Guide。
OC 實例變量:指這個 OC 變量引用的是一個對象(或說這個變量存放的是一個對象)。
Swift 實例屬性:指這個 Swift 屬性引用的是一個對象。
OC 中的實例變量和 Swift 中的實例屬性類似:它是一個變量,這個變量是特定類型類的實例,即對象。
但 OC 的實例變量通常都是私有的,即一個類看不到另一個類的實例變量,Swift 類也看不到 OC 類裡面的。
如果想讓外界訪問實例變量,這個類就需要實現 accessor 方法:一個 setter 和一個 getter。並且 OC 中的 accessor 方法有特定的命名規范:
getter 方法:方法名和實例變量名相同,並且不帶下劃線。比如實例變量名為 myvar 或 _myvar,則 getter 方法名必須是 myvar。
setter 方法:方法名為實例變量名前加 set,比如實例變量名為 myvar 或 _myvar,則 setter 方法為 setMyvar。
OC 提供了 @property,使用這個指令聲明的屬性會自動獲得 setter 和 getter,並且符合命名規范,比如:
@property(nonatomic) CGRect frame;
則 frame 實例變量自動擁有 accessor 方法:getter 為 frame,setter 為 setFrame:。
當 Swift 遇到 OC 中的 @property 時,會自動把它等價為 Swift 中的屬性,上面的 frame 在 Swift 中即:
var frame : CGRect
OC 的屬性名實際是一個語法糖,比如設置 UIView 的 frame 屬性用的是 .frame 語法,實際是調用該屬性的 accessor 方法。
OC 中可以直接調用 setFrame 來設置屬性,但在 Swift 中是不允許的。也就是說,如果 OC 類中有 @property 聲明的屬性,該屬性的 accessor 方法對 Swift 是隱藏的。
OC 的屬性修飾符中有 readonly,它和 Swift 中屬性後的 {get} 類似,表示該屬性是只讀的。也就是說遇到 readonly,Swift 會自動把它看作 {get}。
因為 OC 中屬性名作為訪問方法的「快捷方式」,所以 OC 也把 Swift 的屬性名當作這種「快捷方式」使用,即使你並沒有實現對應的訪問方法。
比如你在 Swift 類中定義了一個屬性名為 prop,那麼在 OC 中你可以直接用 .prop 來訪問這個屬性、讀取或設置它,即使你在 Swift 中並沒有實現任何這樣的訪問方法。其實這個調用被轉接到了隱式訪問方法調用上面去。
在 Swift 中,不需要顯式實現訪問方法,如果你嘗試去實現,編譯器會提醒錯誤。如果想實現這樣的訪問方法,則使用 computed property。比如要設置 ViewController 的 Color 屬性(computed property),在 Swift 中有如下定義:
var color : UIColor { get { print("getter was called.") return UIColor.redColor() } set { print("setter was called.") } }
則在 OC 中可以顯式調用這個屬性的 accessor 方法,並且滿足命名規范:
ViewController* vc = [ViewController new]; //OC方式新建一個ViewController對象 [vc setColor:[UIColor redColor]]; //顯式調用setter, 輸出 setter was called. UIColor* c = [vc color]; //顯式調用getter, 輸出 getter was called
上面代碼表明,在 Swift 中使用 computed property,OC 會認為你實現了 accessor 方法。
甚至可以在 Swift 中改變 accessor 名稱,方法是把 @objc(替換名) 寫到屬性前面:
@objc(hue) var color : UIColor?
這樣,當 OC 中調用這個屬性的 accessor 時,就使用替換後的名稱:getter 是 hue,setter 是 setHue。
另外可以在 setter 中添加額外操作,比如想在 UIView 的子類中對應 OC 的 setFrame: 方法裡添加額外行為:
class Myview : UIView { override var frame : CGRect { didSet { print("g") } } }
Cocoa 框架提供了在運行時動態調用 accessor 的途徑,即在運行時通過字符串 Key 指定需要訪問的屬性 Value,這就是常說的 Key-Value Coding(KVC)機制。
這個機制的原理和通過 selector 名稱調用 respondsToSelector 方法的原理類似(selector 名稱也是一個字符串)。
指定的字符串就稱為 Key,被 Key 定位之後,可以調用該屬性的 setter 或 getter,setter 或 getter 訪問的數據稱為 Value。
KVC 的基石是 NSKeyValueCoding 協議,它是一個 informal protocol,是一個 category,這個 category 被注入到 NSObject 中。
如果 Swift 類對象要使用 KVC,則該對象必須屬於 NSObject 類家族。
KVC 中最基本的方法有兩個:valueForKey: 以及 setValue:forKey:。當某對象調用二者之一時,這個對象便先進行自回應,就是先嘗試有沒有訪問方法,有則調用訪問方法,沒有則直接訪問該 key 名稱對應的實例變量。
另外兩個常用方法是:dictionaryWithValuesForKeys: 和 setValuesForKeysWithDictionary:,這兩個方法允許在字典上用一條語句就訪問(設置或獲取)若干字典內的鍵值對。
KVC 中的 Value 必須是 OC 對象,在 Swift 看來就是 [AnyObject]。當調用 valueForKey: 時,Swift 會接收到一個包裝著 [AnyObject] 的可選對象,隨後就可以把它轉換為需要的類型了。
說某個類是 KVC 兼容(Key-Value Coding compliant),是指這個類提供了對應 key 的訪問方法,或擁有對應 key 的實例變量。
如果嘗試訪問一個不兼容的 key,就會出現運行時異常,比如下面構造一個這樣的異常:
let obj = NSObject() obj.setValue("hello", forKey: "people") //Crash.
如果不想崩潰,該怎麼做呢?
做法就是保證該類中實現了對應 key 的 accessor,或具有對應 key 名稱的實例變量。
比如上面例子中,需要有一個 setter 方法 setPeople,或一個實例變量 people。
需要強調的是:在 Swift 中實例屬性就提供了 accessor 方法。因此,我們可以在任何繼承於 NSObject 的類的 Swift 對象上使用 KVC,只需保證其中有 Key 對應的屬性即可。
比如:
class Dog : NSObject { var name : String = "" } //...使用時: let d = Dog() d.setValue("fido", forKey: "name") //完全可以 print(d.name) //輸出fido, 可以看到起到了作用!
雖說使用 KVC 和 OO 封裝思想背道而馳,但 KVC 在 iOS 編程中還是有用的,尤其在 Cocoa 中有特殊用途,比如:
如果向 NSArray 發送 valueForKey:,相當於對數組中每一個元素對象都發送 valueForKey: 消息,並返回一個新生成的 value 數組,這種方法十分簡便實用。在 NSSet 中也有類似用法。
在 NSDictionary 中實現了 valueForKey:,可以替代 objectForKey:,這在你需要操縱一個字典數組時尤其有用。而 NSMutableDictionary 中的 setValue:forKey: 方法等價於 setObject:forKey:,而且前者設置的 value 可以是 nil,因為設置成 nil 時會自動調用 removeObject:forKey:。
NSSortDescriptor 對數組排序的原理,是向每一個元素發送 valueForKey: 消息,這樣可以方便地對字典數組的元素排序。
NSManagedObject 經常和 Core Data 結合使用。它是 KVC 兼容的,當在實用模式下配置了它的屬性,就可以通過 valueForKey: 以及 setValue:forKey: 來訪問。
CALayer 和 CAAnimation 允許用戶使用 KVC 來定義或修改任意的鍵值,就好像這些鍵值對就是存放在字典中的一樣,而實際上是因為它們 KVC 兼容。這兩個類對象通過 KVC 配置起來非常方便,實際工作中也的確經常用 KVC 來配置它們。
KVC 為 Outlet 提供幕後支持。
nib 中的 Outlet 名稱是一個字符串,KVC 把該名稱作為 Key 來定位到對應的對象屬性上。
假如你有一個 Dog 類,它有個 Outlet 屬性 master,你把這個屬性連線到 nib 文件中的 person 對象上。當 person 對象從 nib 加載時,outlet 的名稱 master 被 KVC 用於調用 accessor 方法 setMaster:,然後 Dog 對象的 set 方法被隱式調用,並把 person 對象設置到 master 上。
如果 nib 文件中的 Outlet 名稱和類中屬性名不對應,就會在運行時出錯。
運行時,當 nib 加載後,Cocoa 會嘗試利用 KVC 來設置 nib 對象到你的一個對象屬性上,如果名稱不對應,就會設置失敗,結果是出現異常,程序會在 nib 加載時崩潰。
這個錯誤常見於先配置好 Outlet,然後不小心修改了屬性名卻沒修改 Outlet 名的情況。
key path 允許用戶用一條語句進行鏈式訪問。若對象兼容某個 Key,而這個 key 對應的屬性又是一個對象且對另外一個 key 是 KVC 兼容的,就可以把這些 key 用在 key 鏈上。
使用 valueForKeyPath: 和 setValue:forKeyPath: 方法來應用 key 鏈進行鏈式訪問。
可以把 KeyPath 看作一個字符串,只是每個 key 用點號分割,如 "key1.key2.key3"。
例如有這樣一個 KeyPath:"key1.key2",在 valueForKeyPath: 中使用它,實際過程是先用 key1 調用 valueForKey:,再在返回值上利用 key2 繼續調用 valueForKey:,以此類推。
比如 myObject 中有一個 theData 屬性:
var theData = [ [ "description" : "The one with glasses.", "name" : "Manny" ], [ "description" : "Looks a little like Governor Deway.", "name" : "Moe" ], ]
這個屬性本身是一個字典數組,可以使用 KVC,並利用 KeyPath 來獲取一個新數組:
let arr = myObject.valueForKeyPath("theData.name") as! [String]
上面代碼中的 KeyPath 先找到 theData 屬性,然後從這個屬性中獲取全部的名字,再構成一個新數組(原理請看 5.3 第一條)。
TIP:nib 中可以設置 user-defined runtime attributes,這個功能也是利用 KVC,而它的第一列所有 key 都可以連成一個 KeyPath。
KVC 是一個強大的技術,並且它還有許多衍生技術(詳見蘋果 Key-Value Coding Programming Guide)。
因為所有 OC 類都繼承自 NSObject,故有必要單獨討論一下 NSObject。
NSObject 的構造十分精巧:
在它裡面實現了一些用於對象實例化及消息的發送和解析的類方法及實例方法(詳見 NSObject Class Reference)。
它接受 NSObject 協議。該協議內聲明了與諸如內存管理、對象和類關系、內省等相關的方法。因為所有 NSObject 協議方法都是 required 的,所以 NSObject 把它們全部實現了。在 Swift 中,NSObject 協議被改名為 NSObjectProtocol,以此避免名字沖突(詳見 NSObject Protocol Reference)。
它實現了 NSCopying、NSMutableCopying 以及 NSCoding 協議相關方法,但沒有接受這些協議(因為這些協議就是在它裡面聲明的)。原因是如果 NSObject 接受了這些協議,意味著所有子類都接受這些協議,這樣並不好。正確的做法是讓需要這些協議的子類去接受,並實現協議內的方法。
NSObject 擁有 20 多個類擴展,向它裡面注入了大量方法,這些類擴展分布在不同的頭文件中。比如 awakeFromNib 方法就是從 UINibLoadingAdditions 類擴展中獲得的,在 UINibLoading.h 中聲明。
一個類(class object)也是對象,並且所有 OC 類都是 Class 類型的對象,這些類都繼承自 NSObject(包括 Class)。所有 NSObject 實例方法都可以被類對象以類方法的形式調用。比如 respondsToSelector 方法是在 NSObject 中定義的對象方法,但這個方法可以被任意類對象作為類方法調用。
如果想弄清楚某個類能夠接收什麼消息,你不用關心這個消息在哪裡聲明,只需弄清楚你可以向這個對象發送哪些消息。但這裡出現一個問題:蘋果的文檔不是以「可以向這個類型的對象發送什麼消息」來組織的,而是以「這個方法在哪裡」的形式來組織的,這就導致了一個對開發者很不友好的情況:
即使是基類 NSObject,文檔中都沒有一個對它完整的描述,而是需要同時查找 NSObject Class Reference 和 NSObject Protocol Reference,外帶 NSCopying、NSMutableCopying、NSCoding 的幫助文檔,再加上對每個 NSObject 對象方法對應的類方法版本的自我理解。
另外還有一些方法是以類擴展形式插入到 NSObject 中的,有些方法列在了 NSObject 的類描述文檔中,但有些需要列出的卻沒有被列出,只有在實際使用時去找。
不管來偷的還是用搶的,只有把所有 NSObject 方法都湊齊的時候,才能真正知道 NSObject 的全貌:
構造、析構以及內存管理:
用於創建對象的方法,如 alloc 和 copy,另外還有一些關於對象生命期的方法,如 initialize 和 dealloc,以及內存管理方法。
類關系描述:
用於確定對象的類和繼承關系,比如 superclass、isKindOfClass 及 isMemberOfClass。
對象自回應和比較:
用於查詢當發送某消息時對象的反應,如 respondsToSelector、用字符串描述對象 description,以及對象比較 isEqual。
消息響應:
向對象發送消息後用於干預對象行為的方法,如 doesNotRecognizeSelector,詳見 Objective-C Runtime Programming Guide。
消息發送:
用於動態發送消息,比如 performSelector 方法,它以 selector 作為參數,讓對象進行 selector 對應的行為。假如直到運行時才知道要發送什麼消息給該對象,就只能用這個方法。另外,performSelector 的變體允許你在特定線程上發送消息,或允許在特定時間間隔後發送消息,比如 performSelector:withObject:afterDelay:。
TIP:performSelector 在 Swift 2.0 之後才可用,之前這個方法不能被 Swift 調用。在實踐中尋找替代思路時發現,不使用這個方法也能很好地把 OC 代碼轉移到 Swift 上。