本章將會介紹

自動引用計數(shù)的工作機制
自動引用計數(shù)實踐
類實例之間的循環(huán)強引用
解決實例之間的循環(huán)強引用
閉包引起的循環(huán)強引用
解決閉包引起的循環(huán)強引用
使用可選鏈?zhǔn)秸{(diào)用代替強制展開
為可選鏈?zhǔn)秸{(diào)用定義模型類
通過可選鏈?zhǔn)秸{(diào)用訪問屬性
通過可選鏈?zhǔn)秸{(diào)用調(diào)用方法
通過可選鏈?zhǔn)秸{(diào)用訪問下標(biāo)
連接多層可選鏈?zhǔn)秸{(diào)用
在方法的可選返回值上進(jìn)行可選鏈?zhǔn)秸{(diào)用
表示并拋出錯誤
處理錯誤
指定清理操作

自動引用計數(shù)

Swift 使用自動引用計數(shù)（ARC）機制來跟蹤和管理你的應(yīng)用程序的內(nèi)存。通常情況下，Swift 內(nèi)存管理機制會一直起作用，你無須自己來考慮內(nèi)存的管理。ARC 會在類的實例不再被使用時，自動釋放其占用的內(nèi)存。

然而在少數(shù)情況下，為了能幫助你管理內(nèi)存，ARC 需要更多的，代碼之間關(guān)系的信息。本章描述了這些情況，并且為你示范怎樣才能使 ARC 來管理你的應(yīng)用程序的所有內(nèi)存。在 Swift 使用 ARC 與在 Obejctive-C 中使用 ARC 非常類似。

注意
引用計數(shù)僅僅應(yīng)用于類的實例。結(jié)構(gòu)體和枚舉類型是值類型，不是引用類型，也不是通過引用的方式存儲和傳遞。

1.自動引用計數(shù)的工作機制

當(dāng)你每次創(chuàng)建一個類的新的實例的時候，ARC 會分配一塊內(nèi)存來儲存該實例信息。內(nèi)存中會包含實例的類型信息，以及這個實例所有相關(guān)的存儲型屬性的值。

此外，當(dāng)實例不再被使用時，ARC 釋放實例所占用的內(nèi)存，并讓釋放的內(nèi)存能挪作他用。這確保了不再被使用的實例，不會一直占用內(nèi)存空間。

然而，當(dāng) ARC 收回和釋放了正在被使用中的實例，該實例的屬性和方法將不能再被訪問和調(diào)用。實際上，如果你試圖訪問這個實例，你的應(yīng)用程序很可能會崩潰。

為了確保使用中的實例不會被銷毀，ARC 會跟蹤和計算每一個實例正在被多少屬性，常量和變量所引用。哪怕實例的引用數(shù)為1，ARC都不會銷毀這個實例。

為了使上述成為可能，無論你將實例賦值給屬性、常量或變量，它們都會創(chuàng)建此實例的強引用。之所以稱之為“強”引用，是因為它會將實例牢牢地保持住，只要強引用還在，實例是不允許被銷毀的。

2.自動引用計數(shù)實踐

下面的例子展示了自動引用計數(shù)的工作機制。例子以一個簡單的Person類開始，并定義了一個叫name的常量屬性：

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) is being initialized")
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}

Person類有一個構(gòu)造函數(shù)，此構(gòu)造函數(shù)為實例的name屬性賦值，并打印一條消息以表明初始化過程生效。Person類也擁有一個析構(gòu)函數(shù)，這個析構(gòu)函數(shù)會在實例被銷毀時打印一條消息。

接下來的代碼片段定義了三個類型為Person?的變量，用來按照代碼片段中的順序，為新的Person實例建立多個引用。由于這些變量是被定義為可選類型（Person?，而不是Person），它們的值會被自動初始化為nil，目前還不會引用到Person類的實例。

var reference1: Person?
var reference2: Person?
var reference3: Person?

現(xiàn)在你可以創(chuàng)建Person類的新實例，并且將它賦值給三個變量中的一個：

reference1 = Person(name: "John Appleseed")
// 打印 "John Appleseed is being initialized”

應(yīng)當(dāng)注意到當(dāng)你調(diào)用Person類的構(gòu)造函數(shù)的時候，“John Appleseed is being initialized”會被打印出來。由此可以確定構(gòu)造函數(shù)被執(zhí)行。

由于Person類的新實例被賦值給了reference1變量，所以reference1到Person類的新實例之間建立了一個強引用。正是因為這一個強引用，ARC 會保證Person實例被保持在內(nèi)存中不被銷毀。

如果你將同一個Person實例也賦值給其他兩個變量，該實例又會多出兩個強引用：

reference2 = reference1
reference3 = reference1

現(xiàn)在這一個Person實例已經(jīng)有三個強引用了。

如果你通過給其中兩個變量賦值nil的方式斷開兩個強引用（包括最先的那個強引用），只留下一個強引用，Person實例不會被銷毀：

reference1 = nil
reference2 = nil

在你清楚地表明不再使用這個Person實例時，即第三個也就是最后一個強引用被斷開時，ARC 會銷毀它：

reference3 = nil
// 打印 “John Appleseed is being deinitialized”

3.類實例之間的循環(huán)強引用

在上面的例子中，ARC 會跟蹤你所新創(chuàng)建的Person實例的引用數(shù)量，并且會在Person實例不再被需要時銷毀它。

然而，我們可能會寫出一個類實例的強引用數(shù)永遠(yuǎn)不能變成0的代碼。如果兩個類實例互相持有對方的強引用，因而每個實例都讓對方一直存在，就是這種情況。這就是所謂的循環(huán)強引用。

你可以通過定義類之間的關(guān)系為弱引用或無主引用，以替代強引用，從而解決循環(huán)強引用的問題。具體的過程在解決類實例之間的循環(huán)強引用中有描述。不管怎樣，在你學(xué)習(xí)怎樣解決循環(huán)強引用之前，很有必要了解一下它是怎樣產(chǎn)生的。

下面展示了一個不經(jīng)意產(chǎn)生循環(huán)強引用的例子。例子定義了兩個類：Person和Apartment，用來建模公寓和它其中的居民：

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

每一個Person實例有一個類型為String，名字為name的屬性，并有一個可選的初始化為nil的apartment屬性。apartment屬性是可選的，因為一個人并不總是擁有公寓。

類似的，每個Apartment實例有一個叫unit，類型為String的屬性，并有一個可選的初始化為nil的tenant屬性。tenant屬性是可選的，因為一棟公寓并不總是有居民。

這兩個類都定義了析構(gòu)函數(shù)，用以在類實例被析構(gòu)的時候輸出信息。這讓你能夠知曉Person和Apartment的實例是否像預(yù)期的那樣被銷毀。

接下來的代碼片段定義了兩個可選類型的變量john和unit4A，并分別被設(shè)定為下面的Apartment和Person的實例。這兩個變量都被初始化為nil，這正是可選類型的優(yōu)點：

var john: Person?
var unit4A: Apartment?

現(xiàn)在你可以創(chuàng)建特定的Person和Apartment實例并將賦值給john和unit4A變量：

john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")

在兩個實例被創(chuàng)建和賦值后，下圖表現(xiàn)了強引用的關(guān)系。變量john現(xiàn)在有一個指向Person實例的強引用，而變量unit4A有一個指向Apartment實例的強引用：

現(xiàn)在你能夠?qū)⑦@兩個實例關(guān)聯(lián)在一起，這樣人就能有公寓住了，而公寓也有了房客。注意感嘆號是用來展開和訪問可選變量john和unit4A中的實例，這樣實例的屬性才能被賦值：

john!.apartment = unit4A
unit4A!.tenant = john

在將兩個實例聯(lián)系在一起之后，強引用的關(guān)系如圖所示：

不幸的是，這兩個實例關(guān)聯(lián)后會產(chǎn)生一個循環(huán)強引用。Person實例現(xiàn)在有了一個指向Apartment實例的強引用，而Apartment實例也有了一個指向Person實例的強引用。因此，當(dāng)你斷開john和unit4A變量所持有的強引用時，引用計數(shù)并不會降為0，實例也不會被 ARC 銷毀：

john = nil
unit4A = nil

注意，當(dāng)你把這兩個變量設(shè)為nil時，沒有任何一個析構(gòu)函數(shù)被調(diào)用。循環(huán)強引用會一直阻止Person和Apartment類實例的銷毀，這就在你的應(yīng)用程序中造成了內(nèi)存泄漏。

在你將john和unit4A賦值為nil后，強引用關(guān)系如下圖：

Person和Apartment實例之間的強引用關(guān)系保留了下來并且不會被斷開。

4.解決實例之間的循環(huán)強引用

Swift 提供了兩種辦法用來解決你在使用類的屬性時所遇到的循環(huán)強引用問題：弱引用（weak reference）和無主引用（unowned reference）。

弱引用和無主引用允許循環(huán)引用中的一個實例引用而另外一個實例不保持強引用。這樣實例能夠互相引用而不產(chǎn)生循環(huán)強引用。

當(dāng)其他的實例有更短的生命周期時，使用弱引用，也就是說，當(dāng)其他實例析構(gòu)在先時。在上面公寓的例子中，很顯然一個公寓在它的生命周期內(nèi)會在某個時間段沒有它的主人，所以一個弱引用就加在公寓類里面，避免循環(huán)引用。相比之下，當(dāng)其他實例有相同的或者更長生命周期時，請使用無主引用。

• 弱引用

弱引用不會對其引用的實例保持強引用，因而不會阻止 ARC 銷毀被引用的實例。這個特性阻止了引用變?yōu)檠h(huán)強引用。聲明屬性或者變量時，在前面加上weak關(guān)鍵字表明這是一個弱引用。

因為弱引用不會保持所引用的實例，即使引用存在，實例也有可能被銷毀。因此，ARC 會在引用的實例被銷毀后自動將其賦值為nil。并且因為弱引用可以允許它們的值在運行時被賦值為nil，所以它們會被定義為可選類型變量，而不是常量。

你可以像其他可選值一樣，檢查弱引用的值是否存在，你將永遠(yuǎn)不會訪問已銷毀的實例的引用。

注意
當(dāng) ARC 設(shè)置弱引用為nil時，屬性觀察不會被觸發(fā)。

下面的例子跟上面Person和Apartment的例子一致，但是有一個重要的區(qū)別。這一次，Apartment的tenant屬性被聲明為弱引用：

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    weak var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

然后跟之前一樣，建立兩個變量（john和unit4A）之間的強引用，并關(guān)聯(lián)兩個實例：

var john: Person?
var unit4A: Apartment?

john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")

john!.apartment = unit4A
unit4A!.tenant = john

Person實例依然保持對Apartment實例的強引用，但是Apartment實例只持有對Person實例的弱引用。這意味著當(dāng)你斷開john變量所保持的強引用時，再也沒有指向Person實例的強引用了：

由于再也沒有指向Person實例的強引用，該實例會被銷毀：

john = nil
// 打印 “John Appleseed is being deinitialized”

唯一剩下的指向Apartment實例的強引用來自于變量unit4A。如果你斷開這個強引用，再也沒有指向Apartment實例的強引用了：

由于再也沒有指向Apartment實例的強引用，該實例也會被銷毀：

unit4A = nil
// 打印 “Apartment 4A is being deinitialized”

上面的兩段代碼展示了變量john和unit4A在被賦值為nil后，Person實例和Apartment實例的析構(gòu)函數(shù)都打印出“銷毀”的信息。這證明了引用循環(huán)被打破了。

注意
在使用垃圾收集的系統(tǒng)里，弱指針有時用來實現(xiàn)簡單的緩沖機制，因為沒有強引用的對象只會在內(nèi)存壓力觸發(fā)垃圾收集時才被銷毀。但是在 ARC 中，一旦值的最后一個強引用被移除，就會被立即銷毀，這導(dǎo)致弱引用并不適合上面的用途。

• 無主引用

和弱引用類似，無主引用不會牢牢保持住引用的實例。和弱引用不同的是，無主引用在其他實例有相同或者更長的生命周期時使用。你可以在聲明屬性或者變量時，在前面加上關(guān)鍵字unowned表示這是一個無主引用。

無主引用通常都被期望擁有值。不過 ARC 無法在實例被銷毀后將無主引用設(shè)為nil，因為非可選類型的變量不允許被賦值為nil。

重要
使用無主引用，你必須確保引用始終指向一個未銷毀的實例。
如果你試圖在實例被銷毀后，訪問該實例的無主引用，會觸發(fā)運行時錯誤。

下面的例子定義了兩個類，Customer和CreditCard，模擬了銀行客戶和客戶的信用卡。這兩個類中，每一個都將另外一個類的實例作為自身的屬性。這種關(guān)系可能會造成循環(huán)強引用。

Customer和CreditCard之間的關(guān)系與前面弱引用例子中Apartment和Person的關(guān)系略微不同。在這個數(shù)據(jù)模型中，一個客戶可能有或者沒有信用卡，但是一張信用卡總是關(guān)聯(lián)著一個客戶。為了表示這種關(guān)系，Customer類有一個可選類型的card屬性，但是CreditCard類有一個非可選類型的customer屬性。

此外，只能通過將一個number值和customer實例傳遞給CreditCard構(gòu)造函數(shù)的方式來創(chuàng)建CreditCard實例。這樣可以確保當(dāng)創(chuàng)建CreditCard實例時總是有一個customer實例與之關(guān)聯(lián)。

由于信用卡總是關(guān)聯(lián)著一個客戶，因此將customer屬性定義為無主引用，用以避免循環(huán)強引用：

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("\(name) is being deinitialized") }
}

class CreditCard {
    let number: UInt64
    unowned let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #\(number) is being deinitialized") }
}

注意
CreditCard類的number屬性被定義為UInt64類型而不是Int類型，以確保number屬性的存儲量在 32 位和 64 位系統(tǒng)上都能足夠容納 16 位的卡號。

下面的代碼片段定義了一個叫john的可選類型Customer變量，用來保存某個特定客戶的引用。由于是可選類型，所以變量被初始化為nil：

var john: Customer?

現(xiàn)在你可以創(chuàng)建Customer類的實例，用它初始化CreditCard實例，并將新創(chuàng)建的CreditCard實例賦值為客戶的card屬性：

john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)

在你關(guān)聯(lián)兩個實例后，它們的引用關(guān)系如下圖所示：

Customer實例持有對CreditCard實例的強引用，而CreditCard實例持有對Customer實例的無主引用。

由于customer的無主引用，當(dāng)你斷開john變量持有的強引用時，再也沒有指向Customer實例的強引用了：

由于再也沒有指向Customer實例的強引用，該實例被銷毀了。其后，再也沒有指向CreditCard實例的強引用，該實例也隨之被銷毀了：

john = nil
// 打印 “John Appleseed is being deinitialized”
// 打印 ”Card #1234567890123456 is being deinitialized”

最后的代碼展示了在john變量被設(shè)為nil后Customer實例和CreditCard實例的構(gòu)造函數(shù)都打印出了“銷毀”的信息。

注意
上面的例子展示了如何使用安全的無主引用。對于需要禁用運行時的安全檢查的情況（例如，出于性能方面的原因），Swift還提供了不安全的無主引用。與所有不安全的操作一樣，你需要負(fù)責(zé)檢查代碼以確保其安全性。 你可以通過unowned(unsafe)來聲明不安全無主引用。如果你試圖在實例被銷毀后，訪問該實例的不安全無主引用，你的程序會嘗試訪問該實例之前所在的內(nèi)存地址，這是一個不安全的操作。

• 無主引用以及隱式解析可選屬性

上面弱引用和無主引用的例子涵蓋了兩種常用的需要打破循環(huán)強引用的場景。

Person和Apartment的例子展示了兩個屬性的值都允許為nil，并會潛在的產(chǎn)生循環(huán)強引用。這種場景最適合用弱引用來解決。

Customer和CreditCard的例子展示了一個屬性的值允許為nil，而另一個屬性的值不允許為nil，這也可能會產(chǎn)生循環(huán)強引用。這種場景最適合通過無主引用來解決。

然而，存在著第三種場景，在這種場景中，兩個屬性都必須有值，并且初始化完成后永遠(yuǎn)不會為nil。在這種場景中，需要一個類使用無主屬性，而另外一個類使用隱式解析可選屬性。

這使兩個屬性在初始化完成后能被直接訪問（不需要可選展開），同時避免了循環(huán)引用。這一節(jié)將為你展示如何建立這種關(guān)系。

下面的例子定義了兩個類，Country和City，每個類將另外一個類的實例保存為屬性。在這個模型中，每個國家必須有首都，每個城市必須屬于一個國家。為了實現(xiàn)這種關(guān)系，Country類擁有一個capitalCity屬性，而City類有一個country屬性：

class Country {
    let name: String
    var capitalCity: City!
    init(name: String, capitalName: String) {
        self.name = name
        self.capitalCity = City(name: capitalName, country: self)
    }
}

class City {
    let name: String
    unowned let country: Country
    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
}

為了建立兩個類的依賴關(guān)系，City的構(gòu)造函數(shù)接受一個Country實例作為參數(shù)，并且將實例保存到country屬性。

Country的構(gòu)造函數(shù)調(diào)用了City的構(gòu)造函數(shù)。然而，只有Country的實例完全初始化后，Country的構(gòu)造函數(shù)才能把self傳給City的構(gòu)造函數(shù)。在兩段式構(gòu)造過程中有具體描述。

為了滿足這種需求，通過在類型結(jié)尾處加上感嘆號（City!）的方式，將Country的capitalCity屬性聲明為隱式解析可選類型的屬性。這意味著像其他可選類型一樣，capitalCity屬性的默認(rèn)值為nil，但是不需要展開它的值就能訪問它。在隱式解析可選類型中有描述。

由于capitalCity默認(rèn)值為nil，一旦Country的實例在構(gòu)造函數(shù)中給name屬性賦值后，整個初始化過程就完成了。這意味著一旦name屬性被賦值后，Country的構(gòu)造函數(shù)就能引用并傳遞隱式的self。Country的構(gòu)造函數(shù)在賦值capitalCity時，就能將self作為參數(shù)傳遞給City的構(gòu)造函數(shù)。

以上的意義在于你可以通過一條語句同時創(chuàng)建Country和City的實例，而不產(chǎn)生循環(huán)強引用，并且capitalCity的屬性能被直接訪問，而不需要通過感嘆號來展開它的可選值：

var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")
// 打印 “Canada's capital city is called Ottawa”

在上面的例子中，使用隱式解析可選值意味著滿足了類的構(gòu)造函數(shù)的兩個構(gòu)造階段的要求。capitalCity屬性在初始化完成后，能像非可選值一樣使用和存取，同時還避免了循環(huán)強引用。

5.閉包引起的循環(huán)強引用

前面我們看到了循環(huán)強引用是在兩個類實例屬性互相保持對方的強引用時產(chǎn)生的，還知道了如何用弱引用和無主引用來打破這些循環(huán)強引用。

循環(huán)強引用還會發(fā)生在當(dāng)你將一個閉包賦值給類實例的某個屬性，并且這個閉包體中又使用了這個類實例時。這個閉包體中可能訪問了實例的某個屬性，例如self.someProperty，或者閉包中調(diào)用了實例的某個方法，例如self.someMethod()。這兩種情況都導(dǎo)致了閉包“捕獲”self，從而產(chǎn)生了循環(huán)強引用。

循環(huán)強引用的產(chǎn)生，是因為閉包和類相似，都是引用類型。當(dāng)你把一個閉包賦值給某個屬性時，你是將這個閉包的引用賦值給了屬性。實質(zhì)上，這跟之前的問題是一樣的——兩個強引用讓彼此一直有效。但是，和兩個類實例不同，這次一個是類實例，另一個是閉包。

Swift 提供了一種優(yōu)雅的方法來解決這個問題，稱之為閉包捕獲列表（closure capture list）。同樣的，在學(xué)習(xí)如何用閉包捕獲列表打破循環(huán)強引用之前，先來了解一下這里的循環(huán)強引用是如何產(chǎn)生的，這對我們很有幫助。

下面的例子為你展示了當(dāng)一個閉包引用了self后是如何產(chǎn)生一個循環(huán)強引用的。例子中定義了一個叫HTMLElement的類，用一種簡單的模型表示 HTML 文檔中的一個單獨的元素：

class HTMLElement {

    let name: String
    let text: String?

    lazy var asHTML: (Void) -> String = {
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) is being deinitialized")
    }

}

HTMLElement類定義了一個name屬性來表示這個元素的名稱，例如代表頭部元素的"h1"，代表段落的“p”，或者代表換行的“br”。HTMLElement還定義了一個可選屬性text，用來設(shè)置 HTML 元素呈現(xiàn)的文本。

除了上面的兩個屬性，HTMLElement還定義了一個lazy屬性asHTML。這個屬性引用了一個將name和text組合成 HTML 字符串片段的閉包。該屬性是Void -> String類型，或者可以理解為“一個沒有參數(shù)，返回String的函數(shù)”。

默認(rèn)情況下，閉包賦值給了asHTML屬性，這個閉包返回一個代表 HTML 標(biāo)簽的字符串。如果text值存在，該標(biāo)簽就包含可選值text；如果text不存在，該標(biāo)簽就不包含文本。對于段落元素，根據(jù)text是“some text”還是nil，閉包會返回"<p>some text</p>"或者"<p />"。

可以像實例方法那樣去命名、使用asHTML屬性。然而，由于asHTML是閉包而不是實例方法，如果你想改變特定 HTML 元素的處理方式的話，可以用自定義的閉包來取代默認(rèn)值。

例如，可以將一個閉包賦值給asHTML屬性，這個閉包能在text屬性是nil時使用默認(rèn)文本，這是為了避免返回一個空的 HTML 標(biāo)簽：

let heading = HTMLElement(name: "h1")
let defaultText = "some default text"
heading.asHTML = {
    return "<\(heading.name)>\(heading.text ?? defaultText)</\(heading.name)>"
}
print(heading.asHTML())
// 打印 “<h1>some default text</h1>”

注意
asHTML聲明為lazy屬性，因為只有當(dāng)元素確實需要被處理為 HTML 輸出的字符串時，才需要使用asHTML。也就是說，在默認(rèn)的閉包中可以使用self，因為只有當(dāng)初始化完成以及self確實存在后，才能訪問lazy屬性。

HTMLElement類只提供了一個構(gòu)造函數(shù)，通過name和text（如果有的話）參數(shù)來初始化一個新元素。該類也定義了一個析構(gòu)函數(shù)，當(dāng)HTMLElement實例被銷毀時，打印一條消息。

下面的代碼展示了如何用HTMLElement類創(chuàng)建實例并打印消息：

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
// 打印 “<p>hello, world</p>”

注意
上面的paragraph變量定義為可選類型的HTMLElement，因此我們可以賦值nil給它來演示循環(huán)強引用。

不幸的是，上面寫的HTMLElement類產(chǎn)生了類實例和作為asHTML默認(rèn)值的閉包之間的循環(huán)強引用。循環(huán)強引用如下圖所示：

實例的asHTML屬性持有閉包的強引用。但是，閉包在其閉包體內(nèi)使用了self（引用了self.name和self.text），因此閉包捕獲了self，這意味著閉包又反過來持有了HTMLElement實例的強引用。這樣兩個對象就產(chǎn)生了循環(huán)強引用。

注意
雖然閉包多次使用了self，它只捕獲HTMLElement實例的一個強引用。

如果設(shè)置paragraph變量為nil，打破它持有的HTMLElement實例的強引用，HTMLElement實例和它的閉包都不會被銷毀，也是因為循環(huán)強引用：

paragraph = nil

注意，HTMLElement的析構(gòu)函數(shù)中的消息并沒有被打印，證明了HTMLElement實例并沒有被銷毀。

6.解決閉包引起的循環(huán)強引用

在定義閉包時同時定義捕獲列表作為閉包的一部分，通過這種方式可以解決閉包和類實例之間的循環(huán)強引用。捕獲列表定義了閉包體內(nèi)捕獲一個或者多個引用類型的規(guī)則。跟解決兩個類實例間的循環(huán)強引用一樣，聲明每個捕獲的引用為弱引用或無主引用，而不是強引用。應(yīng)當(dāng)根據(jù)代碼關(guān)系來決定使用弱引用還是無主引用。

注意
Swift 有如下要求：只要在閉包內(nèi)使用self的成員，就要用self.someProperty或者self.someMethod()（而不只是someProperty或someMethod()）。這提醒你可能會一不小心就捕獲了self。

• 定義捕獲列表

捕獲列表中的每一項都由一對元素組成，一個元素是weak或unowned關(guān)鍵字，另一個元素是類實例的引用（例如self）或初始化過的變量（如delegate = self.delegate!）。這些項在方括號中用逗號分開。

如果閉包有參數(shù)列表和返回類型，把捕獲列表放在它們前面：

lazy var someClosure: (Int, String) -> String = {
    [unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in
    // 這里是閉包的函數(shù)體
}

如果閉包沒有指明參數(shù)列表或者返回類型，即它們會通過上下文推斷，那么可以把捕獲列表和關(guān)鍵字in放在閉包最開始的地方：

lazy var someClosure: Void -> String = {
    [unowned self, weak delegate = self.delegate!] in
    // 這里是閉包的函數(shù)體
}

• 弱引用和無主引用

在閉包和捕獲的實例總是互相引用并且總是同時銷毀時，將閉包內(nèi)的捕獲定義為無主引用。

相反的，在被捕獲的引用可能會變?yōu)閚il時，將閉包內(nèi)的捕獲定義為弱引用。弱引用總是可選類型，并且當(dāng)引用的實例被銷毀后，弱引用的值會自動置為nil。這使我們可以在閉包體內(nèi)檢查它們是否存在。

注意
如果被捕獲的引用絕對不會變?yōu)閚il，應(yīng)該用無主引用，而不是弱引用。

前面的HTMLElement例子中，無主引用是正確的解決循環(huán)強引用的方法。這樣編寫HTMLElement類來避免循環(huán)強引用：

class HTMLElement {

    let name: String
    let text: String?

    lazy var asHTML: (Void) -> String = {
        [unowned self] in
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

上面的HTMLElement實現(xiàn)和之前的實現(xiàn)一致，除了在asHTML閉包中多了一個捕獲列表。這里，捕獲列表是[unowned self]，表示“將self捕獲為無主引用而不是強引用”。

和之前一樣，我們可以創(chuàng)建并打印HTMLElement實例：

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
// 打印 “<p>hello, world</p>”

使用捕獲列表后引用關(guān)系如下圖所示

這一次，閉包以無主引用的形式捕獲self，并不會持有HTMLElement實例的強引用。如果將paragraph賦值為nil，HTMLElement實例將會被銷毀，并能看到它的析構(gòu)函數(shù)打印出的消息：

paragraph = nil
// 打印 “p is being deinitialized”

7.自動引用計數(shù)總結(jié)

自動引用計數(shù)

// 示例
class Person0 {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) is being initialized")
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}

var reference1: Person0?
var reference2: Person0?
var reference3: Person0?
reference1 = Person0(name: "John")
reference2 = reference1
reference3 = reference1
// 現(xiàn)在Person實例有三個強引用了

reference1 = nil // 引用實例變成兩個
reference2 = nil // 引用實例變成1個
reference3 = nil // 引用實例沒有了 調(diào)用析構(gòu)函數(shù)

// 類實例之間的循環(huán)強引用以及解決方法
// 弱引用 Person和Apartment的例子展示了兩個屬性的值都允許為nil，并會潛在的產(chǎn)生循環(huán)強引用。這種場景最適合用弱引用來解決。
class Person {
    let name: String
    init(name: String) {self.name = name}
    var apartment: Apartment?
    deinit {
        print("\(name) is being deinitialized")
    }
}

class Apartment {
    let unit: String
    init(unit: String) {self.unit = unit}
    weak var tenant: Person?
    deinit {
        print("Apartment \(unit) is being deinitialized")
    }
}

var john: Person?
var unit4A: Apartment?
john = Person(name: "John Appleased")
unit4A = Apartment(unit: "4A")

john!.apartment = unit4A
unit4A!.tenant = john

john = nil
unit4A = nil

// 無主引用 Customer和CreditCard的例子展示了一個屬性的值允許為nil，而另一個屬性的值不允許為nil，這也可能會產(chǎn)生循環(huán)強引用。這種場景最適合通過無主引用來解決。
class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) { self.name = name }
    deinit {
        print("\(name) is being deinitialized")
    }
}

class CreditCard {
    let number: UInt64
    unowned let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit {
        print("Card #\(number) is being deinitilized")
    }
}

var henry: Customer?
henry = Customer(name: "Henry Appleased")
henry!.card = CreditCard(number: 1234_5678_9087_3456, customer: henry!)

henry = nil

// 無主引用以及隱式解析可選屬性 兩個屬性都必須有值，并且初始化完成后永遠(yuǎn)不會為nil 在這種場景中，需要一個類使用無主屬性，而另外一個類使用隱式解析可選屬性。
class Country {
    let name: String
    var capitalCity: City!
    init(name: String, capitalName: String) {
        self.name = name
        self.capitalCity = City(name: capitalName, country: self)
    }
}

class City {
    let name: String
    unowned let country: Country
    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
}

var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")


// 閉包引起的循環(huán)強引用
class HTMLElement {

    let name: String
    let text: String?

    lazy var asHTML: (Void) -> String = {
        [unowned self] in
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("hahahah \(name) is being deinitialized")
    }
}
let heading = HTMLElement(name: "h1")
let defaultText = "some default text"
heading.asHTML = {
    return "<\(heading.name)>\(heading.text ?? defaultText)</\(heading.name)>"
}
print(heading.asHTML())

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
// 打印 “<p>hello, world</p>”

paragraph = nil

可選鏈

可選鏈?zhǔn)秸{(diào)用是一種可以在當(dāng)前值可能為nil的可選值上請求和調(diào)用屬性、方法及下標(biāo)的方法。如果可選值有值，那么調(diào)用就會成功；如果可選值是nil，那么調(diào)用將返回nil。多個調(diào)用可以連接在一起形成一個調(diào)用鏈，如果其中任何一個節(jié)點為nil，整個調(diào)用鏈都會失敗，即返回nil。

注意
Swift 的可選鏈?zhǔn)秸{(diào)用和 Objective-C 中向nil發(fā)送消息有些相像，但是 Swift 的可選鏈?zhǔn)秸{(diào)用可以應(yīng)用于任意類型，并且能檢查調(diào)用是否成功。

1.使用可選鏈?zhǔn)秸{(diào)用代替強制展開

通過在想調(diào)用的屬性、方法、或下標(biāo)的可選值后面放一個問號（?），可以定義一個可選鏈。這一點很像在可選值后面放一個嘆號（!）來強制展開它的值。它們的主要區(qū)別在于當(dāng)可選值為空時可選鏈?zhǔn)秸{(diào)用只會調(diào)用失敗，然而強制展開將會觸發(fā)運行時錯誤。

為了反映可選鏈?zhǔn)秸{(diào)用可以在空值（nil）上調(diào)用的事實，不論這個調(diào)用的屬性、方法及下標(biāo)返回的值是不是可選值，它的返回結(jié)果都是一個可選值。你可以利用這個返回值來判斷你的可選鏈?zhǔn)秸{(diào)用是否調(diào)用成功，如果調(diào)用有返回值則說明調(diào)用成功，返回nil則說明調(diào)用失敗。

特別地，可選鏈?zhǔn)秸{(diào)用的返回結(jié)果與原本的返回結(jié)果具有相同的類型，但是被包裝成了一個可選值。例如，使用可選鏈?zhǔn)秸{(diào)用訪問屬性，當(dāng)可選鏈?zhǔn)秸{(diào)用成功時，如果屬性原本的返回結(jié)果是Int類型，則會變?yōu)镮nt?類型。

下面幾段代碼將解釋可選鏈?zhǔn)秸{(diào)用和強制展開的不同。

首先定義兩個類Person和Residence：

class Person {
    var residence: Residence?
}

class Residence {
    var numberOfRooms = 1
}

Residence有一個Int類型的屬性numberOfRooms，其默認(rèn)值為1。Person具有一個可選的residence屬性，其類型為Residence?。

假如你創(chuàng)建了一個新的Person實例,它的residence屬性由于是是可選型而將初始化為nil,在下面的代碼中,john有一個值為nil的residence屬性：

let john = Person()

如果使用嘆號（!）強制展開獲得這個john的residence屬性中的numberOfRooms值，會觸發(fā)運行時錯誤，因為這時residence沒有可以展開的值：

let roomCount = john.residence!.numberOfRooms
// 這會引發(fā)運行時錯誤

john.residence為非nil值的時候，上面的調(diào)用會成功，并且把roomCount設(shè)置為Int類型的房間數(shù)量。正如上面提到的，當(dāng)residence為nil的時候上面這段代碼會觸發(fā)運行時錯誤。

可選鏈?zhǔn)秸{(diào)用提供了另一種訪問numberOfRooms的方式，使用問號（?）來替代原來的嘆號（!）

if let roomCount = john.residence?.numberOfRooms {
    print("John's residence has \(roomCount) room(s).")
} else {
    print("Unable to retrieve the number of rooms.")
}
// 打印 “Unable to retrieve the number of rooms.”

在residence后面添加問號之后，Swift 就會在residence不為nil的情況下訪問numberOfRooms。

因為訪問numberOfRooms有可能失敗，可選鏈?zhǔn)秸{(diào)用會返回Int?類型，或稱為“可選的 Int”。如上例所示，當(dāng)residence為nil的時候，可選的Int將會為nil，表明無法訪問numberOfRooms。訪問成功時，可選的Int值會通過可選綁定展開，并賦值給非可選類型的roomCount常量。

要注意的是，即使numberOfRooms是非可選的Int時，這一點也成立。只要使用可選鏈?zhǔn)秸{(diào)用就意味著numberOfRooms會返回一個Int?而不是Int。

可以將一個Residence的實例賦給john.residence，這樣它就不再是nil了：

john.residence = Residence()

john.residence現(xiàn)在包含一個實際的Residence實例，而不再是nil。如果你試圖使用先前的可選鏈?zhǔn)秸{(diào)用訪問numberOfRooms，它現(xiàn)在將返回值為1的Int?類型的值：

if let roomCount = john.residence?.numberOfRooms {
    print("John's residence has \(roomCount) room(s).")
} else {
    print("Unable to retrieve the number of rooms.")
}
// 打印 “John's residence has 1 room(s).”

2.為可選鏈?zhǔn)秸{(diào)用定義模型類

通過使用可選鏈?zhǔn)秸{(diào)用可以調(diào)用多層屬性、方法和下標(biāo)。這樣可以在復(fù)雜的模型中向下訪問各種子屬性，并且判斷能否訪問子屬性的屬性、方法或下標(biāo)。

下面這段代碼定義了四個模型類，這些例子包括多層可選鏈?zhǔn)秸{(diào)用。為了方便說明，在Person和Residence的基礎(chǔ)上增加了Room類和Address類，以及相關(guān)的屬性、方法以及下標(biāo)。

Person類的定義基本保持不變：

class Person {
    var residence: Residence?
}

Residence類比之前復(fù)雜些，增加了一個名為rooms的變量屬性，該屬性被初始化為[Room]類型的空數(shù)組：

class Residence {
    var rooms = [Room]()
    var numberOfRooms: Int {
        return rooms.count
    }
    subscript(i: Int) -> Room {
        get {
            return rooms[i]
        }
        set {
            rooms[i] = newValue
        }
    }
    func printNumberOfRooms() {
        print("The number of rooms is \(numberOfRooms)")
    }
    var address: Address?
}

現(xiàn)在Residence有了一個存儲Room實例的數(shù)組，numberOfRooms屬性被實現(xiàn)為計算型屬性，而不是存儲型屬性。numberOfRooms屬性簡單地返回rooms數(shù)組的count屬性的值。

Residence還提供了訪問rooms數(shù)組的快捷方式，即提供可讀寫的下標(biāo)來訪問rooms數(shù)組中指定位置的元素。

此外，Residence還提供了printNumberOfRooms方法，這個方法的作用是打印numberOfRooms的值。

最后，Residence還定義了一個可選屬性address，其類型為Address?。Address類的定義在下面會說明。

Room類是一個簡單類，其實例被存儲在rooms數(shù)組中。該類只包含一個屬性name，以及一個用于將該屬性設(shè)置為適當(dāng)?shù)姆块g名的初始化函數(shù)：

class Room {
    let name: String
    init(name: String) { self.name = name }
}

最后一個類是Address，這個類有三個String?類型的可選屬性。buildingName以及buildingNumber屬性分別表示某個大廈的名稱和號碼，第三個屬性street表示大廈所在街道的名稱：

class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if buildingName != nil {
            return buildingName
        } else if buildingNumber != nil && street != nil {
            return "\(buildingNumber) \(street)"
        } else {
            return nil
        }
    }
}

Address類提供了buildingIdentifier()方法，返回值為String?。 如果buildingName有值則返回buildingName?；蛘?，如果buildingNumber和street均有值則返回buildingNumber。否則，返回nil。

3.通過可選鏈?zhǔn)秸{(diào)用訪問屬性

正如使用可選鏈?zhǔn)秸{(diào)用代替強制展開中所述，可以通過可選鏈?zhǔn)秸{(diào)用在一個可選值上訪問它的屬性，并判斷訪問是否成功。

下面的代碼創(chuàng)建了一個Person實例，然后像之前一樣，嘗試訪問numberOfRooms屬性：

let john = Person()
if let roomCount = john.residence?.numberOfRooms {
    print("John's residence has \(roomCount) room(s).")
} else {
    print("Unable to retrieve the number of rooms.")
}
// 打印 “Unable to retrieve the number of rooms.”

因為john.residence為nil，所以這個可選鏈?zhǔn)秸{(diào)用依舊會像先前一樣失敗。

還可以通過可選鏈?zhǔn)秸{(diào)用來設(shè)置屬性值：

let someAddress = Address()
someAddress.buildingNumber = "29"
someAddress.street = "Acacia Road"
john.residence?.address = someAddress

在這個例子中，通過john.residence來設(shè)定address屬性也會失敗，因為john.residence當(dāng)前為nil。

上面代碼中的賦值過程是可選鏈?zhǔn)秸{(diào)用的一部分，這意味著可選鏈?zhǔn)秸{(diào)用失敗時，等號右側(cè)的代碼不會被執(zhí)行。對于上面的代碼來說，很難驗證這一點，因為像這樣賦值一個常量沒有任何副作用。下面的代碼完成了同樣的事情，但是它使用一個函數(shù)來創(chuàng)建Address實例，然后將該實例返回用于賦值。該函數(shù)會在返回前打印“Function was called”，這使你能驗證等號右側(cè)的代碼是否被執(zhí)行。

func createAddress() -> Address {
    print("Function was called.")

    let someAddress = Address()
    someAddress.buildingNumber = "29"
    someAddress.street = "Acacia Road"

    return someAddress
}
john.residence?.address = createAddress()

沒有任何打印消息，可以看出createAddress()函數(shù)并未被執(zhí)行。

4.通過可選鏈?zhǔn)秸{(diào)用調(diào)用方法

可以通過可選鏈?zhǔn)秸{(diào)用來調(diào)用方法，并判斷是否調(diào)用成功，即使這個方法沒有返回值。

Residence類中的printNumberOfRooms()方法打印當(dāng)前的numberOfRooms值，如下所示：

func printNumberOfRooms() {
    print("The number of rooms is \(numberOfRooms)")
}

這個方法沒有返回值。然而，沒有返回值的方法具有隱式的返回類型Void，如無返回值函數(shù)中所述。這意味著沒有返回值的方法也會返回()，或者說空的元組。

如果在可選值上通過可選鏈?zhǔn)秸{(diào)用來調(diào)用這個方法，該方法的返回類型會是Void?，而不是Void，因為通過可選鏈?zhǔn)秸{(diào)用得到的返回值都是可選的。這樣我們就可以使用if語句來判斷能否成功調(diào)用printNumberOfRooms()方法，即使方法本身沒有定義返回值。通過判斷返回值是否為nil可以判斷調(diào)用是否成功：

if john.residence?.printNumberOfRooms() != nil {
    print("It was possible to print the number of rooms.")
} else {
    print("It was not possible to print the number of rooms.")
}
// 打印 “It was not possible to print the number of rooms.”

同樣的，可以據(jù)此判斷通過可選鏈?zhǔn)秸{(diào)用為屬性賦值是否成功。在上面的通過可選鏈?zhǔn)秸{(diào)用訪問屬性的例子中，我們嘗試給john.residence中的address屬性賦值，即使residence為nil。通過可選鏈?zhǔn)秸{(diào)用給屬性賦值會返回Void?，通過判斷返回值是否為nil就可以知道賦值是否成功：

if (john.residence?.address = someAddress) != nil {
    print("It was possible to set the address.")
} else {
    print("It was not possible to set the address.")
}
// 打印 “It was not possible to set the address.”

5.通過可選鏈?zhǔn)秸{(diào)用訪問下標(biāo)

通過可選鏈?zhǔn)秸{(diào)用，我們可以在一個可選值上訪問下標(biāo)，并且判斷下標(biāo)調(diào)用是否成功。

注意
通過可選鏈?zhǔn)秸{(diào)用訪問可選值的下標(biāo)時，應(yīng)該將問號放在下標(biāo)方括號的前面而不是后面?？蛇x鏈?zhǔn)秸{(diào)用的問號一般直接跟在可選表達(dá)式的后面。

下面這個例子用下標(biāo)訪問john.residence屬性存儲的Residence實例的rooms數(shù)組中的第一個房間的名稱，因為john.residence為nil，所以下標(biāo)調(diào)用失敗了：

if let firstRoomName = john.residence?[0].name {
    print("The first room name is \(firstRoomName).")
} else {
    print("Unable to retrieve the first room name.")
}
// 打印 “Unable to retrieve the first room name.”

在這個例子中，問號直接放在john.residence的后面，并且在方括號的前面，因為john.residence是可選值。

類似的，可以通過下標(biāo)，用可選鏈?zhǔn)秸{(diào)用來賦值：

john.residence?[0] = Room(name: "Bathroom")

這次賦值同樣會失敗，因為residence目前是nil。

如果你創(chuàng)建一個Residence實例，并為其rooms數(shù)組添加一些Room實例，然后將Residence實例賦值給john.residence，那就可以通過可選鏈和下標(biāo)來訪問數(shù)組中的元素：

let johnsHouse = Residence()
johnsHouse.rooms.append(Room(name: "Living Room"))
johnsHouse.rooms.append(Room(name: "Kitchen"))
john.residence = johnsHouse

if let firstRoomName = john.residence?[0].name {
    print("The first room name is \(firstRoomName).")
} else {
    print("Unable to retrieve the first room name.")
}
// 打印 “The first room name is Living Room.”

訪問可選類型的下標(biāo)

如果下標(biāo)返回可選類型值，比如 Swift 中Dictionary類型的鍵的下標(biāo)，可以在下標(biāo)的結(jié)尾括號后面放一個問號來在其可選返回值上進(jìn)行可選鏈?zhǔn)秸{(diào)用：

var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
testScores["Dave"]?[0] = 91
testScores["Bev"]?[0] += 1
testScores["Brian"]?[0] = 72
// "Dave" 數(shù)組現(xiàn)在是 [91, 82, 84]，"Bev" 數(shù)組現(xiàn)在是 [80, 94, 81]

上面的例子中定義了一個testScores數(shù)組，包含了兩個鍵值對，把String類型的鍵映射到一個Int值的數(shù)組。這個例子用可選鏈?zhǔn)秸{(diào)用把"Dave"數(shù)組中第一個元素設(shè)為91，把"Bev"數(shù)組的第一個元素+1，然后嘗試把"Brian"數(shù)組中的第一個元素設(shè)為72。前兩個調(diào)用成功，因為testScores字典中包含"Dave"和"Bev"這兩個鍵。但是testScores字典中沒有"Brian"這個鍵，所以第三個調(diào)用失敗。

6.連接多層可選鏈?zhǔn)秸{(diào)用

可以通過連接多個可選鏈?zhǔn)秸{(diào)用在更深的模型層級中訪問屬性、方法以及下標(biāo)。然而，多層可選鏈?zhǔn)秸{(diào)用不會增加返回值的可選層級。

也就是說：

• 如果你訪問的值不是可選的，可選鏈?zhǔn)秸{(diào)用將會返回可選值。
• 如果你訪問的值就是可選的，可選鏈?zhǔn)秸{(diào)用不會讓可選返回值變得“更可選”。

因此：

• 通過可選鏈?zhǔn)秸{(diào)用訪問一個Int值，將會返回Int?，無論使用了多少層可選鏈?zhǔn)秸{(diào)用。
• 類似的，通過可選鏈?zhǔn)秸{(diào)用訪問Int?值，依舊會返回Int?值，并不會返回Int??。

下面的例子嘗試訪問john中的residence屬性中的address屬性中的street屬性。這里使用了兩層可選鏈?zhǔn)秸{(diào)用，residence以及address都是可選值：

if let johnsStreet = john.residence?.address?.street {
    print("John's street name is \(johnsStreet).")
} else {
    print("Unable to retrieve the address.")
}
// 打印 “Unable to retrieve the address.”

john.residence現(xiàn)在包含一個有效的Residence實例。然而，john.residence.address的值當(dāng)前為nil。因此，調(diào)用john.residence?.address?.street會失敗。

需要注意的是，上面的例子中，street的屬性為String?。john.residence?.address?.street的返回值也依然是String?，即使已經(jīng)使用了兩層可選鏈?zhǔn)秸{(diào)用。

如果為john.residence.address賦值一個Address實例，并且為address中的street屬性設(shè)置一個有效值，我們就能過通過可選鏈?zhǔn)秸{(diào)用來訪問street屬性：

let johnsAddress = Address()
johnsAddress.buildingName = "The Larches"
johnsAddress.street = "Laurel Street"
john.residence?.address = johnsAddress

if let johnsStreet = john.residence?.address?.street {
    print("John's street name is \(johnsStreet).")
} else {
    print("Unable to retrieve the address.")
}
// 打印 “John's street name is Laurel Street.”

在上面的例子中，因為john.residence包含一個有效的Residence實例，所以對john.residence的address屬性賦值將會成功。

7.在方法的可選返回值上進(jìn)行可選鏈?zhǔn)秸{(diào)用

上面的例子展示了如何在一個可選值上通過可選鏈?zhǔn)秸{(diào)用來獲取它的屬性值。我們還可以在一個可選值上通過可選鏈?zhǔn)秸{(diào)用來調(diào)用方法，并且可以根據(jù)需要繼續(xù)在方法的可選返回值上進(jìn)行可選鏈?zhǔn)秸{(diào)用。

在下面的例子中，通過可選鏈?zhǔn)秸{(diào)用來調(diào)用Address的buildingIdentifier()方法。這個方法返回String?類型的值。如上所述，通過可選鏈?zhǔn)秸{(diào)用來調(diào)用該方法，最終的返回值依舊會是String?類型：

if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
    print("John's building identifier is \(buildingIdentifier).")
}
// 打印 “John's building identifier is The Larches.”

如果要在該方法的返回值上進(jìn)行可選鏈?zhǔn)秸{(diào)用，在方法的圓括號后面加上問號即可：

if let beginsWithThe =
    john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
        if beginsWithThe {
            print("John's building identifier begins with \"The\".")
        } else {
            print("John's building identifier does not begin with \"The\".")
        }
}
// 打印 “John's building identifier begins with "The".”

注意
在上面的例子中，在方法的圓括號后面加上問號是因為你要在buildingIdentifier()方法的可選返回值上進(jìn)行可選鏈?zhǔn)秸{(diào)用，而不是方法本身。

8.可選鏈總結(jié)

可選鏈

class Person {
    var residence: Residence?
}

class Residence {
    var rooms = [Room]()
    var numbweOfRooms: Int {
        return rooms.count
    }
    subscript(i: Int) -> Room {
        get {
            return rooms[i]
        }
        set {
            rooms[i] = newValue
        }
    }
    func printNumberOfRooms() {
        print("The number of rooms is \(numbweOfRooms)")
    }
    var address: Address?
}

class Room {
    let name: String
    init(name: String) { self.name = name }
}

class Address {
    var buildingName: String?
    var buildingNumber: String?
    var street: String?
    func buildingIdentifier() -> String? {
        if buildingName != nil {
            return buildingName
        } else if buildingNumber != nil && street != nil {
            return "\(buildingNumber) \(street)"
        } else {
            return nil
        }
    }
}



let john = Person()
if let roomCount = john.residence?.numbweOfRooms {
    print("John住宅有\(zhòng)(roomCount)個房間")
} else {
    print("無法獲取房間數(shù)")
}

let someAddress = Address()
someAddress.buildingNumber = "29"
someAddress.street = "Acacid Road"
john.residence?.address = someAddress

if john.residence?.printNumberOfRooms() == nil {
    print("It was possible to print the number of rooms.")
} else {
    print("It was not possible to print the number of rooms.")
}

if john.residence?.address != nil {
    print("It was possible to set the address.")
} else {
    print("It was not possible to set the address.")
}

if let firstRoomName = john.residence?[0].name {
    print("The first room name is \(firstRoomName).")
} else {
    print("Unable to retrieve the first room name.")
}

john.residence?[0] = Room(name: "Bathroom")

let johnHouse = Residence()
johnHouse.rooms.append(Room(name: "Living Room"))
johnHouse.rooms.append(Room(name: "Kitchen"))
john.residence = johnHouse

if let firstRoomName = john.residence?[0].name {
    print("The first room name is \(firstRoomName).")
} else {
    print("Unable to retrieve the first room name.")
}

if let johnsStreet = john.residence?.address?.street {
    print("John's street name is \(johnsStreet).")
} else {
    print("Unable to retrieve the address.")
}

let johnsAddress = Address()
johnsAddress.buildingName = "The Larches"
johnsAddress.street = "Laurel Street"
john.residence?.address = johnsAddress

if let johnsStreet = john.residence?.address?.street {
    print("John's street name is \(johnsStreet).")
} else {
    print("Unable to retrieve the address.")
}

if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
    print("John's building identifier is \(buildingIdentifier).")
}

if let beginsWithThe = john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
    beginsWithThe ? print("John's building identifier begins with \"The\".") : print("John's building identifier does not begin with \"The\".")

//    if beginsWithThe {
//        print("John's building identifier begins with \"The\".")
//    } else {
//        print("John's building identifier does not begin with \"The\".")
//    }
}

錯誤處理

錯誤處理（Error handling）是響應(yīng)錯誤以及從錯誤中恢復(fù)的過程。Swift 提供了在運行時對可恢復(fù)錯誤的拋出、捕獲、傳遞和操作的一等公民支持。

某些操作無法保證總是執(zhí)行完所有代碼或總是生成有用的結(jié)果。可選類型可用來表示值缺失，但是當(dāng)某個操作失敗時，最好能得知失敗的原因，從而可以作出相應(yīng)的應(yīng)對。

舉個例子，假如有個從磁盤上的某個文件讀取數(shù)據(jù)并進(jìn)行處理的任務(wù)，該任務(wù)會有多種可能失敗的情況，包括指定路徑下文件并不存在，文件不具有可讀權(quán)限，或者文件編碼格式不兼容。區(qū)分這些不同的失敗情況可以讓程序解決并處理某些錯誤，然后把它解決不了的錯誤報告給用戶。

1.表示并拋出錯誤

在 Swift 中，錯誤用符合Error協(xié)議的類型的值來表示。這個空協(xié)議表明該類型可以用于錯誤處理。

Swift 的枚舉類型尤為適合構(gòu)建一組相關(guān)的錯誤狀態(tài)，枚舉的關(guān)聯(lián)值還可以提供錯誤狀態(tài)的額外信息。例如，你可以這樣表示在一個游戲中操作自動販賣機時可能會出現(xiàn)的錯誤狀態(tài)：

enum VendingMachineError: Error {
    case invalidSelection                    //選擇無效
    case insufficientFunds(coinsNeeded: Int) //金額不足
    case outOfStock                          //缺貨
}

拋出一個錯誤可以讓你表明有意外情況發(fā)生，導(dǎo)致正常的執(zhí)行流程無法繼續(xù)執(zhí)行。拋出錯誤使用throw關(guān)鍵字。例如，下面的代碼拋出一個錯誤，提示販賣機還需要5個硬幣：

throw VendingMachineError. insufficientFunds(coinsNeeded: 5)

2.處理錯誤

某個錯誤被拋出時，附近的某部分代碼必須負(fù)責(zé)處理這個錯誤，例如糾正這個問題、嘗試另外一種方式、或是向用戶報告錯誤。

Swift 中有4種處理錯誤的方式。你可以把函數(shù)拋出的錯誤傳遞給調(diào)用此函數(shù)的代碼、用do-catch語句處理錯誤、將錯誤作為可選類型處理、或者斷言此錯誤根本不會發(fā)生。每種方式在下面的小節(jié)中都有描述。

當(dāng)一個函數(shù)拋出一個錯誤時，你的程序流程會發(fā)生改變，所以重要的是你能迅速識別代碼中會拋出錯誤的地方。為了標(biāo)識出這些地方，在調(diào)用一個能拋出錯誤的函數(shù)、方法或者構(gòu)造器之前，加上try關(guān)鍵字，或者try?或try!這種變體。這些關(guān)鍵字在下面的小節(jié)中有具體講解。

注意
Swift 中的錯誤處理和其他語言中用try，catch和throw進(jìn)行異常處理很像。和其他語言中（包括 Objective-C ）的異常處理不同的是，Swift 中的錯誤處理并不涉及解除調(diào)用棧，這是一個計算代價高昂的過程。就此而言，throw語句的性能特性是可以和return語句相媲美的。

• 用 throwing 函數(shù)傳遞錯誤

為了表示一個函數(shù)、方法或構(gòu)造器可以拋出錯誤，在函數(shù)聲明的參數(shù)列表之后加上throws關(guān)鍵字。一個標(biāo)有throws關(guān)鍵字的函數(shù)被稱作throwing 函數(shù)。如果這個函數(shù)指明了返回值類型，throws關(guān)鍵詞需要寫在箭頭（->）的前面。

func canThrowErrors() throws -> String
func cannotThrowErrors() -> String

一個 throwing 函數(shù)可以在其內(nèi)部拋出錯誤，并將錯誤傳遞到函數(shù)被調(diào)用時的作用域。

注意
只有 throwing 函數(shù)可以傳遞錯誤。任何在某個非 throwing 函數(shù)內(nèi)部拋出的錯誤只能在函數(shù)內(nèi)部處理。

下面的例子中，VendingMachine類有一個vend(itemNamed:)方法，如果請求的物品不存在、缺貨或者投入金額小于物品價格，該方法就會拋出一個相應(yīng)的VendingMachineError：

struct Item {
    var price: Int
    var count: Int
}

class VendingMachine {
    var inventory = [
        "Candy Bar": Item(price: 12, count: 7),
        "Chips": Item(price: 10, count: 4),
        "Pretzels": Item(price: 7, count: 11)
    ]
    var coinsDeposited = 0
    func dispenseSnack(snack: String) {
        print("Dispensing \(snack)")
    }

    func vend(itemNamed name: String) throws {
        guard let item = inventory[name] else {
            throw VendingMachineError.InvalidSelection
        }

        guard item.count > 0 else {
            throw VendingMachineError.OutOfStock
        }

        guard item.price <= coinsDeposited else {
            throw VendingMachineError.InsufficientFunds(coinsNeeded: item.price - coinsDeposited)
        }

        coinsDeposited -= item.price

        var newItem = item
        newItem.count -= 1
        inventory[name] = newItem

        print("Dispensing \(name)")
    }
}

在vend(itemNamed:)方法的實現(xiàn)中使用了guard語句來提前退出方法，確保在購買某個物品所需的條件中，有任一條件不滿足時，能提前退出方法并拋出相應(yīng)的錯誤。由于throw語句會立即退出方法，所以物品只有在所有條件都滿足時才會被售出。

因為vend(itemNamed:)方法會傳遞出它拋出的任何錯誤，在你的代碼中調(diào)用此方法的地方，必須要么直接處理這些錯誤——使用do-catch語句，try?或try!；要么繼續(xù)將這些錯誤傳遞下去。例如下面例子中，buyFavoriteSnack(person:vendingMachine:)同樣是一個 throwing 函數(shù)，任何由vend(itemNamed:)方法拋出的錯誤會一直被傳遞到buyFavoriteSnack(person:vendingMachine:)函數(shù)被調(diào)用的地方。

let favoriteSnacks = [
    "Alice": "Chips",
    "Bob": "Licorice",
    "Eve": "Pretzels",
]
func buyFavoriteSnack(person: String, vendingMachine: VendingMachine) throws {
    let snackName = favoriteSnacks[person] ?? "Candy Bar"
    try vendingMachine.vend(itemNamed: snackName)
}

上例中，buyFavoriteSnack(person:vendingMachine:)函數(shù)會查找某人最喜歡的零食，并通過調(diào)用vend(itemNamed:)方法來嘗試為他們購買。因為vend(itemNamed:)方法能拋出錯誤，所以在調(diào)用的它時候在它前面加了try關(guān)鍵字。

throwing構(gòu)造器能像throwing函數(shù)一樣傳遞錯誤.例如下面代碼中的PurchasedSnack構(gòu)造器在構(gòu)造過程中調(diào)用了throwing函數(shù),并且通過傳遞到它的調(diào)用者來處理這些錯誤。

struct PurchasedSnack {
    let name: String
    init(name: String, vendingMachine: VendingMachine) throws {
        try vendingMachine.vend(itemNamed: name)
        self.name = name
    }
}

• 用 Do-Catch 處理錯誤

可以使用一個do-catch語句運行一段閉包代碼來處理錯誤。如果在do子句中的代碼拋出了一個錯誤，這個錯誤會與catch子句做匹配，從而決定哪條子句能處理它。

下面是do-catch語句的一般形式：

do {
    try expression
    statements
} catch pattern 1 {
    statements
} catch pattern 2 where condition {
    statements
}

在catch后面寫一個匹配模式來表明這個子句能處理什么樣的錯誤。如果一條catch子句沒有指定匹配模式，那么這條子句可以匹配任何錯誤，并且把錯誤綁定到一個名字為error的局部常量。

catch子句不必將do子句中的代碼所拋出的每一個可能的錯誤都作處理。如果所有catch子句都未處理錯誤，錯誤就會傳遞到周圍的作用域。然而，錯誤還是必須要被某個周圍的作用域處理的——要么是一個外圍的do-catch錯誤處理語句，要么是一個 throwing 函數(shù)的內(nèi)部。舉例來說，下面的代碼處理了VendingMachineError枚舉類型的全部枚舉值，但是所有其它的錯誤就必須由它周圍的作用域處理：

var vendingMachine = VendingMachine()
vendingMachine.coinsDeposited = 8
do {
    try buyFavoriteSnack(person: "Alice", vendingMachine: vendingMachine)
} catch VendingMachineError.InvalidSelection {
    print("Invalid Selection.")
} catch VendingMachineError.OutOfStock {
    print("Out of Stock.")
} catch VendingMachineError.InsufficientFunds(let coinsNeeded) {
    print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.")
}
// 打印 “Insufficient funds. Please insert an additional 2 coins.”

上面的例子中，buyFavoriteSnack(person:vendingMachine:)函數(shù)在一個try表達(dá)式中調(diào)用，因為它能拋出錯誤。如果錯誤被拋出，相應(yīng)的執(zhí)行會馬上轉(zhuǎn)移到catch子句中，并判斷這個錯誤是否要被繼續(xù)傳遞下去。如果沒有錯誤拋出，do子句中余下的語句就會被執(zhí)行。

• 將錯誤轉(zhuǎn)換成可選值

可以使用try?通過將錯誤轉(zhuǎn)換成一個可選值來處理錯誤。如果在評估try?表達(dá)式時一個錯誤被拋出，那么表達(dá)式的值就是nil。例如,在下面的代碼中,x和y有著相同的數(shù)值和等價的含義：

func someThrowingFunction() throws -> Int {
    // ...
}

let x = try? someThrowingFunction()

let y: Int?
do {
    y = try someThrowingFunction()
} catch {
    y = nil
}

如果someThrowingFunction()拋出一個錯誤，x和y的值是nil。否則x和y的值就是該函數(shù)的返回值。注意，無論someThrowingFunction()的返回值類型是什么類型，x和y都是這個類型的可選類型。例子中此函數(shù)返回一個整型，所以x和y是可選整型。

如果你想對所有的錯誤都采用同樣的方式來處理，用try?就可以讓你寫出簡潔的錯誤處理代碼。例如，下面的代碼用幾種方式來獲取數(shù)據(jù)，如果所有方式都失敗了則返回nil：

func fetchData() -> Data? {
    if let data = try? fetchDataFromDisk() { return data }
    if let data = try? fetchDataFromServer() { return data }
    return nil
}

• 禁用錯誤傳遞

有時你知道某個throwing函數(shù)實際上在運行時是不會拋出錯誤的，在這種情況下，你可以在表達(dá)式前面寫try!來禁用錯誤傳遞，這會把調(diào)用包裝在一個不會有錯誤拋出的運行時斷言中。如果真的拋出了錯誤，你會得到一個運行時錯誤。

例如，下面的代碼使用了loadImage(atPath:)函數(shù)，該函數(shù)從給定的路徑加載圖片資源，如果圖片無法載入則拋出一個錯誤。在這種情況下，因為圖片是和應(yīng)用綁定的，運行時不會有錯誤拋出，所以適合禁用錯誤傳遞：

let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")

3.指定清理操作

可以使用defer語句在即將離開當(dāng)前代碼塊時執(zhí)行一系列語句。該語句讓你能執(zhí)行一些必要的清理工作，不管是以何種方式離開當(dāng)前代碼塊的——無論是由于拋出錯誤而離開，還是由于諸如return或者break的語句。例如，你可以用defer語句來確保文件描述符得以關(guān)閉，以及手動分配的內(nèi)存得以釋放。

defer語句將代碼的執(zhí)行延遲到當(dāng)前的作用域退出之前。該語句由defer關(guān)鍵字和要被延遲執(zhí)行的語句組成。延遲執(zhí)行的語句不能包含任何控制轉(zhuǎn)移語句，例如break或是return語句，或是拋出一個錯誤。延遲執(zhí)行的操作會按照它們被指定時的順序的相反順序執(zhí)行——也就是說，第一條defer語句中的代碼會在第二條defer語句中的代碼被執(zhí)行之后才執(zhí)行，以此類推。

func processFile(filename: String) throws {
    if exists(filename) {
        let file = open(filename)
        defer {
            close(file)
        }
        while let line = try file.readline() {
            // 處理文件。
        }
        // close(file) 會在這里被調(diào)用，即作用域的最后。
    }
}

上面的代碼使用一條defer語句來確保open(_:)函數(shù)有一個相應(yīng)的對close(_:)函數(shù)的調(diào)用。

注意
即使沒有涉及到錯誤處理，你也可以使用defer語句。

4.錯誤處理總結(jié)

錯誤處理

// 表示并拋出錯誤，錯誤用符合Error協(xié)議的類型的值來表示，這個空協(xié)議表明該類型可以用于錯誤處理
enum VendingMachineError: Error {
    case invalidSelection   // 選擇無效
    case insufficientFunds(coinsNeeded: Int)  // 金額不足
    case outOfStock         // 缺貨
}

// 錯誤處理 1 用throwing函數(shù)傳遞錯誤
struct Item {
    var price: Int
    var count: Int
}

class VendingMachine {
    var inventory = [
        "Candy Bar": Item(price: 12, count: 7),
        "Chips": Item(price: 10, count: 4),
        "Pretzels": Item(price: 7, count: 11)
    ]
    var coinsDeposited = 0
    func dispenseSnack(snack: String) {
        print("Dispensing \(snack)")
    }

    func vend(itemNamed name: String) throws {
        guard let item = inventory[name] else { throw VendingMachineError.invalidSelection }
        guard item.count > 0 else { throw VendingMachineError.outOfStock }
        guard item.price <= coinsDeposited  else { throw VendingMachineError.insufficientFunds(coinsNeeded: item.price - coinsDeposited ) }

        coinsDeposited -= item.price

        var newItem = item
        newItem.count -= 1
        inventory[name] = newItem
        print("Dispensing \(name)")
    }
}

let favoriteSnacks = [
    "Alice": "Chips",
    "Bob": "Licorice",
    "Eve": "Pretzels",
]
func buyFavoriteSnack(person: String, vendingMachine: VendingMachine) throws {
    let snackName = favoriteSnacks[person] ?? "Candy Bar"
    try vendingMachine.vend(itemNamed: snackName)
}

var vendingMachine = VendingMachine()
vendingMachine.coinsDeposited = 8
do {
    try buyFavoriteSnack(person: "Alice2", vendingMachine: vendingMachine)
} catch VendingMachineError.invalidSelection {
    print("Invalid Selection")
} catch VendingMachineError.outOfStock {
    print("Out Of Stock")
} catch VendingMachineError.insufficientFunds(let coinsNeeded) {
    print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.")
}