本頁包含內(nèi)容：

[TOC]

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

然而在少數(shù)情況下，為了能幫助你管理內(nèi)存，ARC需要更多的，代碼之間關(guān)系的信息。

本章描述了這些情況，并且為你示范怎樣才能使 ARC 來管理你的應(yīng)用程序的所有內(nèi)存。在 Swift 使用 ARC 與在 Obejctive-C 中使用 ARC 非常類似。

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

自動引用計數(shù)的工作機(jī)制

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

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

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

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

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

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

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

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

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

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

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

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

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類的新實(shí)例被賦值給了reference1變量，所以reference1到Person類的新實(shí)例之間建立了一個強(qiáng)引用。正是因?yàn)檫@一個強(qiáng)引用，ARC 會保證Person實(shí)例被保持在內(nèi)存中不被銷毀。

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

reference2 = reference1
reference3 = reference1

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

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

reference1 = nil
reference2 = nil

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

reference3 = nil
// 打印 "John Appleseed is being deinitialized"

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

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

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

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

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

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

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

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

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

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

接下來的代碼片段定義了兩個可選類型的變量john和unit4A，并分別被設(shè)定為下面的Apartment和Person的實(shí)例。這兩個變量都被初始化為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")

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

[圖片上傳失敗...(image-5dfc41-1520591196293)]

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

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

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

[圖片上傳失敗...(image-4e4e99-1520591196293)]

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

john = nil
unit4A = nil

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

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

[圖片上傳失敗...(image-2a310f-1520591196293)]

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

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

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

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

當(dāng)其他的實(shí)例有更短的生命周期時，使用弱引用，也就是說，當(dāng)其他實(shí)例析構(gòu)在先時。

在上面公寓的例子中，很顯然一個公寓在它的生命周期內(nèi)會在某個時間段沒有它的主人，所以一個弱引用就加在公寓類里面，避免循環(huán)引用。

相比之下，當(dāng)其他實(shí)例有相同或者更長的生命周期時，請使用無主引用。

弱引用

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

因?yàn)槿跻貌粫３炙玫膶?shí)例，即使引用存在，實(shí)例也有可能被銷毀。因此，ARC會在引用的實(shí)例被銷毀后自動將其賦值為nil。并且因?yàn)槿跻每梢栽试S它們的值在運(yùn)行時被賦值為nil，所以它們會被定義為可選類型變量，而不是常量。

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

注意：當(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 begin deinitialized") }
}

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

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

var john: Person?
var unit4A: Apartment?

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

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

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

[圖片上傳失敗...(image-7d476d-1520591196293)]

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

[圖片上傳失敗...(image-e7efb2-1520591196293)]

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

john = nil
// 打印 "John Appleseed is being deinitialized"

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

[圖片上傳失敗...(image-7f7ef0-1520591196293)]

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

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

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

無主引用

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

無主引用通常都被期望擁有值。不過ARC無法在實(shí)例被銷毀后將無主引用設(shè)為nil，因?yàn)榉强蛇x類型的變量不允許被賦值為nil。

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

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

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

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

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

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit {
        print("\(name) is begin 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 begin deinitialized")
    }
}

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

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

var john: Customer?

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

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

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

[圖片上傳失敗...(image-3fb2bb-1520591196293)]

Customer實(shí)例持有對CreditCard實(shí)例的強(qiáng)引用，而CreditCard實(shí)例持有對Customer實(shí)例的無主引用。

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

[圖片上傳失敗...(image-eed4e8-1520591196293)]

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

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

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

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

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

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

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

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

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

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

下面的例子定義了兩個類，Country和City，每個類將另外一個類的實(shí)例保存為屬性。在這個模型中，每個國家必須有首都，每個城市必須屬于一個國家。為了實(shí)現(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í)例作為參數(shù)，并且將實(shí)例保存到country屬性。

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

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

由于capitalCity默認(rèn)值為nil，一旦Country的實(shí)例在構(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的實(shí)例，而不產(chǎn)生循環(huán)強(qiáng)引用，并且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)強(qiáng)引用。

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

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

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

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

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

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

class HTMLElement {
    let name: String
    let text: String?
    lazy var asHTML: () -> 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 begin 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 />"。

可以像實(shí)例方法那樣去命名、使用asHTML屬性。然而，由于asHTML是閉包而不是實(shí)例方法，如果你想改變特定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屬性，因?yàn)橹挥挟?dāng)元素確實(shí)需要被處理為HTML輸出的字符串時，才需要使用asHTML。也就是說，在默認(rèn)的閉包中可以使用self，因?yàn)橹挥挟?dāng)初始化完成以及self確實(shí)存在后，才能訪問lazy屬性。

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

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

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

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

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

[圖片上傳失敗...(image-b1c774-1520591196293)]

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

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

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

paragraph = nil

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

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

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

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

定義捕獲列表

捕獲列表中的每一項都由一對元素組成，一個元素是weak或unowned關(guān)鍵字，另一個元素是類實(shí)例的引用（例如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: () -> String = {
    [unowned self, weak delegate = self.delegate!] in
    // 這里是閉包的函數(shù)體
}

弱引用和無主引用

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

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

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

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

class HTMLElement {
    let name: String
    let text: String?
    lazy var asHTML: () -> 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閉包中多了一個捕獲列表。這里，捕獲列表是 [unowned self]，表示“將self捕獲為無主引用而不是強(qiáng)引用”。

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

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

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

[圖片上傳失敗...(image-523156-1520591196293)]

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