官方文檔

Swift使用自動(dòng)引用計(jì)數(shù)(ARC)機(jī)制來追蹤和管理你的app的內(nèi)存。在大多數(shù)情況，這意味著Swift的內(nèi)存管理機(jī)制會(huì)一直起作用，你不需要自己考慮內(nèi)存管理。當(dāng)不再需要類的實(shí)例時(shí)，ARC會(huì)自動(dòng)釋放類所占用的內(nèi)存。

然而，在少數(shù)情況下，ARC為了能幫助你管理內(nèi)存，需要更多的關(guān)于你的代碼之間關(guān)系的信息。本章描述了這些情況，以及向你展示如何啟用ARC來管理你的app的內(nèi)存。

注意

引用計(jì)數(shù)只應(yīng)用于類的實(shí)例。結(jié)構(gòu)體和枚舉是值類型，不是引用類型，沒有通過引用的方式存儲(chǔ)和傳遞。

ARC的工作機(jī)制

每次你創(chuàng)建一個(gè)類的實(shí)例，ARC會(huì)分配一大塊內(nèi)存來存儲(chǔ)實(shí)例的信息。這些內(nèi)存中保留有實(shí)例類型的信息，以及該實(shí)例所有存儲(chǔ)屬性的值信息。

此外，當(dāng)實(shí)例不需要時(shí)，ARC會(huì)釋放該實(shí)例所占用的內(nèi)存，釋放的內(nèi)存用于其他用途。這確保類實(shí)例當(dāng)它不在需要時(shí)，不會(huì)一直占用內(nèi)存。

然而，如果ARC釋放了正在使用的實(shí)例內(nèi)存，那么它將不會(huì)訪問實(shí)例的屬性，或者調(diào)用實(shí)例的方法。確實(shí)，如果你試圖訪問該實(shí)例，你的app很可能會(huì)崩潰。

為了確保使用中的實(shí)例不會(huì)消失，ARC會(huì)跟蹤和計(jì)算當(dāng)前實(shí)例被多少屬性，常量和變量所引用。只要存在對(duì)該類實(shí)例的引用，ARC將不會(huì)釋放該實(shí)例。

為了使這些成為可能，無論你將實(shí)例分配給屬性，常量或變量，它們都會(huì)創(chuàng)建該實(shí)例的強(qiáng)引用。之所以稱之為“強(qiáng)(strong)”引用，是因?yàn)樗鼤?huì)將實(shí)例保持住，只要強(qiáng)引用還在，實(shí)例是不允許被銷毀的。

ARC

下面的例子，展示了自動(dòng)引用計(jì)數(shù)的工作機(jī)制。這個(gè)例子由一個(gè)簡單的Person類開始，定義了一個(gè)名為name的存儲(chǔ)常量屬性:

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

Person類有一個(gè)初始化器，它設(shè)置了實(shí)例的name屬性并且輸出一條信息表明初始化器生效。Person類也有一個(gè)反初始化器，會(huì)在類的實(shí)例被銷毀的時(shí)候打印一條信息。

下面的代碼片段定義了三個(gè)Peroson?類型的變量，用來按照代碼中的順序，為新的Person實(shí)例設(shè)置多個(gè)引用。由于可選類型的變量會(huì)被自動(dòng)初始化為一個(gè)nil值，目前還不會(huì)引用到Person類的實(shí)例。

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

你可以創(chuàng)建一個(gè)新的Person實(shí)例并且將它賦值給三個(gè)變量中的一個(gè)：

reference1 = Person(name: "John Appleseed")
// prints "John Appleseed is being initialized"

注意，當(dāng)調(diào)用person類的出初始化器的時(shí)候，會(huì)輸出"John Appleseed is being initialized"信息。這就說明初始化執(zhí)行了。

因?yàn)?code>Person實(shí)例已經(jīng)賦值給了reference1變量，現(xiàn)在就有了一個(gè)從reference1到該實(shí)例的強(qiáng)引用。因?yàn)橹辽儆幸粋€(gè)強(qiáng)引用，ARC可以確保Person一直保持在內(nèi)存中不被銷毀。

如果你將同一個(gè)Person實(shí)例分配給了兩個(gè)變量，則該實(shí)例又會(huì)多出兩個(gè)強(qiáng)引用：

reference2 = reference1
reference3 = reference1

現(xiàn)在這一個(gè)Person實(shí)例就有了三個(gè)強(qiáng)引用。

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

reference1 = nil
reference2 = nil

在你清楚地表明不再使用這個(gè)Person實(shí)例時(shí)，即第三個(gè)也就是最后一個(gè)強(qiáng)引用被斷開時(shí)ARC 會(huì)銷毀它。

reference3 = nil
// prints "John Appleseed is being deinitialized"

類實(shí)例之間的循環(huán)強(qiáng)引用

在上面的例子中，ARC能夠追蹤你所創(chuàng)建的Person實(shí)例的引用數(shù)量，并且會(huì)在Person實(shí)例不在使用時(shí)銷毀。

然而，永遠(yuǎn)不要寫出類實(shí)例強(qiáng)引用為0的代碼。如果兩個(gè)類實(shí)例彼此持有一個(gè)強(qiáng)引用，因而每個(gè)實(shí)例都讓對(duì)方一直存在，就可能發(fā)生這種情況。這就是所謂的循環(huán)強(qiáng)引用。

解決循環(huán)強(qiáng)引用問題，可以通過定義類之間的關(guān)系為弱(weak)引用或無主(unknown)引用來代替強(qiáng)引用。這個(gè)過程在解決類實(shí)例之間的循環(huán)強(qiáng)引用中有描述。然而，在你學(xué)習(xí)時(shí)如何解決循環(huán)強(qiáng)引用問題，就很有必要了解它是如何產(chǎn)生的。

下面的例子展示了一個(gè)如何錯(cuò)誤創(chuàng)建一個(gè)循環(huán)強(qiáng)引用。這個(gè)例子定義了兩個(gè)類，分別是Person和Apartment，用來建模公寓和它其中的居民:

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

每一個(gè)Person實(shí)例有一個(gè)類型為String，名字為name的屬性，并有一個(gè)可選的初始化為nil的apartment屬性。apartment屬性是可選的，因?yàn)橐粋€(gè)人并不總是擁有公寓。

類似的，每個(gè)Apartment實(shí)例有一個(gè)叫number，類型為Int的屬性，并有一個(gè)可選的初始化為nil的tenant屬性。tenant屬性是可選的，因?yàn)橐粭澒⒉⒉豢偸怯芯用瘛?/p>

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

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

var john: Person?
var unit4A: Apartment?

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

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

在兩個(gè)實(shí)例的強(qiáng)引用創(chuàng)建和分配之后，下圖表現(xiàn)了強(qiáng)引用的關(guān)系。John變量對(duì)Person實(shí)例有一個(gè)強(qiáng)引用，unit4A變量對(duì)Apartment實(shí)例有一個(gè)強(qiáng)引用:

現(xiàn)在你可以把這兩個(gè)實(shí)例關(guān)聯(lián)在一起，這樣人就有公寓了，而且公寓有房間號(hào)。注意，感嘆號(hào)(!)是用來展開和訪問可選變量john和unit4A的實(shí)例，所以這些實(shí)例的屬性可以被設(shè)置:

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

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

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

john = nil
unit4A = nil

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

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

解決實(shí)例之間的循環(huán)強(qiáng)引用

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

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

對(duì)于生命周期中會(huì)變?yōu)?code>nil的實(shí)例使用弱引用。相反地，對(duì)于初始化賦值后再也不會(huì)被賦值為nil的實(shí)例，使用無主引用。

若引用

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

在實(shí)例的生命周期中，當(dāng)引用可能沒有值的時(shí)候，可以使用弱引用來避免循環(huán)引用。如果引用始終有值，則可以使用無主引用來代替。在無主引用中描述。上面的Apartment例子中，在它的聲明周期中，有時(shí)是"沒有居民"的，因此適合使用弱引用來解決循環(huán)強(qiáng)引用。

注意

若引用必須被聲明為變量，表明其值能在運(yùn)行時(shí)被修改。若引用不能聲明為常量。

因?yàn)槿粢迷试S"沒有值"，你必須聲明每個(gè)若引用為一個(gè)可選類型。在 Swift 中，推薦使用可選類型描述可能沒有值的類型。

因?yàn)槿粢貌粫?huì)保持引用的實(shí)例，即使弱引用存在，實(shí)例也可能被銷毀。因此，當(dāng)引用的實(shí)例銷毀的時(shí)候，ARC會(huì)自動(dòng)設(shè)置若引用為nil。你可以像其他可選值一樣，檢查弱引用的值是否存在，你將永遠(yuǎn)不會(huì)訪問已銷毀的實(shí)例的引用。

下面的例子跟上面Person和Apartment的例子一致，但是有一個(gè)重要的區(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") 
    }
}

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

var john: Person?
var unit4A: Apartment?
john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")
john!.apartment = unit4A
unit4A!.tenant = john

現(xiàn)在，兩個(gè)關(guān)聯(lián)在一起的實(shí)例的引用關(guān)系如下圖所示：

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

由于再也沒有指向Person實(shí)例的強(qiáng)引用，該實(shí)例會(huì)被銷毀：

john = nil
// prints "John Appleseed is being deinitialized"

唯一剩下的指向Apartment實(shí)例的強(qiáng)引用來自于變量unit4A。如果你斷開這個(gè)強(qiáng)引用，再也沒有指向Apartment實(shí)例的強(qiáng)引用了：

由于再也沒有指向Apartment實(shí)例的強(qiáng)引用，該實(shí)例也會(huì)被銷毀：

unit4A = nil
// prints "Apartment 4A is being deinitialized"

無主引用

和弱引用類似，無主引用不會(huì)牢牢保持住引用的實(shí)例。但是不像若引用，無主引用是永遠(yuǎn)有值的。因?yàn)闊o主引用總是被定義為非可選類型（non-optional type）。你可以在聲明屬性或者變量時(shí)，在前面加上關(guān)鍵字unowned表示這是一個(gè)無主引用。

由于無主引用是非可選類型，你不需要在使用它的時(shí)候?qū)⑺归_。無主引用總是可以被直接訪問。不過 ARC 無法在實(shí)例被銷毀后將無主引用設(shè)為nil，因?yàn)榉强蛇x類型的變量不允許被賦值為nil。

注意
如果你試圖在實(shí)例的被銷毀后訪問無主引用，那么你將觸發(fā)運(yùn)行時(shí)錯(cuò)誤。當(dāng)你確保引用會(huì)一直引用一個(gè)實(shí)例的時(shí)候，在使用無主引用。
還要注意的是，如果你試圖訪問實(shí)例已經(jīng)被銷毀的無主引用，Swift 確保程序會(huì)直接崩潰，而不會(huì)發(fā)生無法預(yù)期的行為。所以你應(yīng)當(dāng)避免這樣的事情發(fā)生。

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

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

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

class Customer {
    let name: Stirng
    var card: CarditCard?
    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屬性的存儲(chǔ)量在32位和64位系統(tǒng)上都能足夠容納16位的卡號(hào)。

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

var john: Customer?

你可以創(chuàng)建一個(gè)Customer實(shí)例，用它初始化和分配一個(gè)新的CreditCard實(shí)例作為customer的card屬性:

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

如下圖，是你關(guān)聯(lián)了兩個(gè)實(shí)例后的圖示關(guān)系:

現(xiàn)在Customer實(shí)例對(duì)CreditCard實(shí)例有一個(gè)強(qiáng)引用，并且CreditCard實(shí)例對(duì)Customer實(shí)例有一個(gè)無主引用。

由于Customer的無主引用，當(dāng)你斷開john變量持有的強(qiáng)引用時(shí)，那么就再也沒有指向Customer實(shí)例的強(qiáng)引用了。

因?yàn)椴辉谟?code>Customer的強(qiáng)引用，該實(shí)例被銷毀了。其后，再也沒有指向CreditCard實(shí)例的強(qiáng)引用，該實(shí)例也隨之被銷毀了：

john = nil
// prints "John Appleseed is being deinitialized"
// prints "Card #1234567890123456 is being deinitialized"

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

無主引用和隱式解析可選屬性

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

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

Customer和CreditCard的例子展示了一個(gè)屬性的值允許為nil，而另一個(gè)屬性的值不允許為nil，這也可能導(dǎo)致循環(huán)強(qiáng)引用。這種場景最好使用無主引用來解決。

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

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

下面的例子定義了兩個(gè)類，Country和City，每個(gè)類將另外一個(gè)類的實(shí)例保存為屬性。在這個(gè)數(shù)據(jù)模型中，每個(gè)國家必須有首都，每個(gè)城市必須屬于一個(gè)國家。為了實(shí)現(xiàn)這種關(guān)系，Country類擁有一個(gè)capitalCity屬性，而City類有一個(gè)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: Stirng, country: Country) {
        self.name = name
        self.country = country
    }
}

為了建立兩個(gè)類的依賴關(guān)系，City的初始化函數(shù)有一個(gè)Country實(shí)例的參數(shù)，并且將實(shí)例保存為country屬性。

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

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

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

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

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

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

閉包引起的循環(huán)強(qiáng)引用

上面我們看到了荀晗強(qiáng)引用是在兩個(gè)實(shí)例屬性互相保持對(duì)方的強(qiáng)音喲過時(shí)產(chǎn)生的，還知道了如何用弱引用和無主引用來打破這些循環(huán)強(qiáng)引用。

循環(huán)強(qiáng)引用還會(huì)出現(xiàn)在當(dāng)你把一個(gè)閉包分配給類實(shí)例的屬性的時(shí)候，并且這個(gè)閉包中又使用了這個(gè)實(shí)例。這個(gè)閉包體中可能訪問了實(shí)例的某個(gè)屬性，例如self.someProperty，或者這個(gè)閉包調(diào)用了一個(gè)實(shí)例的方法，例如self.someMethod()。這兩種情況都導(dǎo)致了閉包 “捕獲" self，從而產(chǎn)生了循環(huán)強(qiáng)引用。

循環(huán)強(qiáng)引用的產(chǎn)生，是因?yàn)殚]包和類相似，都是引用類型。當(dāng)你把閉包分配給了一個(gè)屬性，你也把一個(gè)引用分配給了這個(gè)閉包。實(shí)質(zhì)上，這跟之前上面的問題是一樣的--兩個(gè)強(qiáng)引用讓彼此一直有效。然而，和兩個(gè)類實(shí)例不同，這次一個(gè)是類實(shí)例，另一個(gè)是閉包。

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

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

class HTMLElement {
    let name: String
    let text: String?
    lazy var asHTML: Void -> String = {
        if var asNTML = 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類定義了一個(gè)name屬性來表示這個(gè)元素的名稱，例如代表段落的"p"，或者代表換行的"br"。HTMLElement還定義了一個(gè)可選屬性text，用來設(shè)置和展現(xiàn) HTML 元素的文本。

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

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

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

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

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

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

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
// prints"hello, world"

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

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

實(shí)例的asHTML屬性持有閉包的強(qiáng)引用。但是，閉包在其閉包體內(nèi)使用了self（引用了self.name和self.text），因此閉包捕獲了self，這意味著閉包又反過來持有了HTMLElement實(shí)例的強(qiáng)引用。這樣兩個(gè)對(duì)象就產(chǎn)生了循環(huán)強(qiáng)引用。（更多關(guān)于閉包捕獲值的信息，請參考值捕獲）。

注意:
雖然閉包多次使用了self，它只捕獲HTMLElement實(shí)例的一個(gè)強(qiáng)引用。

如果設(shè)置paragraph變量為nil，打破它持有的HTMLElement實(shí)例的強(qiáng)引用，HTMLElement實(shí)例和它的閉包都不會(huì)被銷毀，也是因?yàn)檠h(huán)強(qiáng)引用：

paragraph = nil

注意HTMLElementdeinitializer中的消息并沒有被打印，證明了HTMLElement實(shí)例并沒有被銷毀。

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

你可以通過定義捕獲列表作為閉包的定義來解決在閉包和類實(shí)例之間的循環(huán)強(qiáng)引用。捕獲列表定義了當(dāng)在閉包體里捕獲一個(gè)或多個(gè)引用類型的規(guī)則。正如在兩個(gè)類實(shí)例之間的循環(huán)強(qiáng)引用，聲明每個(gè)捕獲的引用為引用或無主引用而不是強(qiáng)引用。應(yīng)當(dāng)根據(jù)代碼關(guān)系來決定使用弱引用還是無主引用。

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

定義捕獲列表

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

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

lazy var  someClosure: (Int， String) -> String = {
    [unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in
    // closure body goes here
}

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

lazy var someClosure: Void -> String = {
    [unowned self, weak delegate = self.delegate!] in
    // closure body goes here
}

弱引用和無主引用

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

相反，在被捕獲的引用可能會(huì)變?yōu)?code>nil時(shí)，定義一個(gè)弱引用的捕獲。弱引用總是可選類型，當(dāng)實(shí)例的引用銷毀的時(shí)候會(huì)自動(dòng)變?yōu)?code>nil。這使我們可以在閉包體內(nèi)檢查它們是否存在。

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

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

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實(shí)現(xiàn)和之前的實(shí)現(xiàn)一致，除了在asHTML閉包中多了一個(gè)捕獲列表。這里，捕獲列表是[unowned self]，表示“用無主引用而不是強(qiáng)引用來捕獲self”。

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

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

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

這一次，閉包以無主引用的形式捕獲self，并不會(huì)持有HTMLElement實(shí)例的強(qiáng)引用。如果將paragraph賦值為nil，HTMLElement實(shí)例將會(huì)被銷毀，并能看到它的反初始化函數(shù)打印出的消息。

paragraph = nil
// prints "p is being deinitialized"

了解更多關(guān)于捕獲列表，請看捕獲列表。