Swift編程語言中文教程（十六）：Swift自動引用計數(shù)
本頁包含內(nèi)容：
- 自動引用計數(shù)的工作機制
- 自動引用計數(shù)實踐
- 類實例之間的循環(huán)強引用
- 解決實例之間的循環(huán)強引用
- 閉包引起的循環(huán)強引用
- 解決閉包引起的循環(huán)強引用
Swift 使用自動引用計數(shù)（ARC）這一機制來跟蹤和管理你的應用程序的內(nèi)存。通常情況下，Swift 的內(nèi)存管理機制會一直起著作用，你無須自己來考慮內(nèi)存的管理。ARC 會在類的實例不再被使用時，自動釋放其占用的內(nèi)存。
然而，在少數(shù)情況下，ARC 為了能幫助你管理內(nèi)存，需要更多的關(guān)于你的代碼之間關(guān)系的信息。本章描述了這些情況，并且為你示范怎樣啟用 ARC 來管理你的應用程序的內(nèi)存。
注意:
引用計數(shù)僅僅應用于類的實例。結(jié)構(gòu)體和枚舉類型是值類型，不是引用類型，也不是通過引用的方式存儲和傳遞。
自動引用計數(shù)的工作機制
當你每次創(chuàng)建一個類的新的實例的時候，ARC 會分配一大塊內(nèi)存用來儲存實例的信息。內(nèi)存中會包含實例的類型信息，以及這個實例所有相關(guān)屬性的值。此外，當實例不再被使用時，ARC 釋放實例所占用的內(nèi)存，并讓釋放的內(nèi)存能挪作他用。這確保了不再被使用的實例，不會一直占用內(nèi)存空間。
然而，當 ARC 收回和釋放了正在被使用中的實例，該實例的屬性和方法將不能再被訪問和調(diào)用。實際上，如果你試圖訪問這個實例，你的應用程序很可能會崩潰。
為了確保使用中的實例不會被銷毀，ARC 會跟蹤和計算每一個實例正在被多少屬性，常量和變量所引用。哪怕實例的引用數(shù)為一，ARC都不會銷毀這個實例。
為了使之成為可能，無論你將實例賦值給屬性，常量或者是變量，屬性，常量或者變量，都會對此實例創(chuàng)建強引用。之所以稱之為強引用，是因為它會將實例牢牢的保持住，只要強引用還在，實例是不允許被銷毀的。
自動引用計數(shù)實踐
下面的例子展示了自動引用計數(shù)的工作機制。例子以一個簡單的Person類開始，并定義了一個叫name的常量屬性：
class Person {
let name: String
init(name: String) {
self.name = name
println("\(name) is being initialized")
}
deinit {
println("\(name) is being deinitialized")
}
}
Person類有一個構(gòu)造函數(shù)，此構(gòu)造函數(shù)為實例的name屬性賦值并打印出信息，以表明初始化過程生效。Person類同時也擁有析構(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") // prints "John Appleseed is being initialized”
應當注意到當你調(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實例不會被銷毀：
reference2 = nil reference3 = nil
ARC 會在第三個，也即最后一個強引用被斷開的時候，銷毀Person實例，這也意味著你不再使用這個Person實例：
reference3 = nil // prints "John Appleseed is being deinitialized"
類實例之間的循環(huán)強引用
在上面的例子中，ARC 會跟蹤你所新創(chuàng)建的Person實例的引用數(shù)量，并且會在Person實例不再被需要時銷毀它。
然而，我們可能會寫出這樣的代碼，一個類永遠不會有0個強引用。這種情況發(fā)生在兩個類實例互相保持對方的強引用，并讓對方不被銷毀。這就是所謂的循環(huán)強引用。
你可以通過定義類之間的關(guān)系為弱引用或者無主引用，以此替代強引用，從而解決循環(huán)強引用的問題。具體的過程在解決類實例之間的循環(huán)強引用中有描述。不管怎樣，在你學習怎樣解決循環(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 { println("\(name) is being deinitialized") }
}
class Apartment {
let number: Int
init(number: Int) { self.number = number }
var tenant: Person?
deinit { println("Apartment #\(number) is being deinitialized") }
}
每一個Person實例有一個類型為String，名字為name的屬性，并有一個可選的初始化為nil的apartment屬性。apartment屬性是可選的，因為一個人并不總是擁有公寓。
類似的，每個Apartment實例有一個叫number，類型為Int的屬性，并有一個可選的初始化為nil的tenant屬性。tenant屬性是可選的，因為一棟公寓并不總是有居民。
這兩個類都定義了析構(gòu)函數(shù)，用以在類實例被析構(gòu)的時候輸出信息。這讓你能夠知曉Person和Apartment的實例是否像預期的那樣被銷毀。
接下來的代碼片段定義了兩個可選類型的變量john和number73,并分別被設(shè)定為下面的Apartment和Person的實例。這兩個變量都被初始化為nil，并為可選的：
var john: Person? var number73: Apartment?
現(xiàn)在你可以創(chuàng)建特定的Person和Apartment實例并將類實例賦值給john和number73變量：
john = Person(name: "John Appleseed") number73 = Apartment(number: 73)
在兩個實例被創(chuàng)建和賦值后，下圖表現(xiàn)了強引用的關(guān)系。變量john現(xiàn)在有一個指向Person實例的強引用，而變量number73有一個指向Apartment實例的強引用：
現(xiàn)在你能夠?qū)⑦@兩個實例關(guān)聯(lián)在一起，這樣人就能有公寓住了，而公寓也有了房客。注意感嘆號是用來展開和訪問可選變量john和number73中的實例，這樣實例的屬性才能被賦值：
john!.apartment = number73 number73!.tenant = john
在將兩個實例聯(lián)系在一起之后，強引用的關(guān)系如圖所示：
不幸的是，將這兩個實例關(guān)聯(lián)在一起之后，一個循環(huán)強引用被創(chuàng)建了。Person實例現(xiàn)在有了一個指向Apartment實例的強引用，而Apartment實例也有了一個指向Person實例的強引用。因此，當你斷開john和number73變量所持有的強引用時，引用計數(shù)并不會降為 0，實例也不會被 ARC 銷毀：
john = nil number73 = nil
注意，當你把這兩個變量設(shè)為nil時，沒有任何一個析構(gòu)函數(shù)被調(diào)用。強引用循環(huán)阻止了Person和Apartment類實例的銷毀，并在你的應用程序中造成了內(nèi)存泄漏。
在你將john和number73賦值為nil后，強引用關(guān)系如下圖：
Person和Apartment實例之間的強引用關(guān)系保留了下來并且不會被斷開。
解決實例之間的循環(huán)強引用
Swift 提供了兩種辦法用來解決你在使用類的屬性時所遇到的循環(huán)強引用問題：弱引用（weak reference）和無主引用（unowned reference）。
弱引用和無主引用允許循環(huán)引用中的一個實例引用另外一個實例而不保持強引用。這樣實例能夠互相引用而不產(chǎn)生循環(huán)強引用。
對于生命周期中會變?yōu)閚il的實例使用弱引用。相反的，對于初始化賦值后再也不會被賦值為nil的實例，使用無主引用。
弱引用
弱引用不會牢牢保持住引用的實例，并且不會阻止 ARC 銷毀被引用的實例。這種行為阻止了引用變?yōu)檠h(huán)強引用。聲明屬性或者變量時，在前面加上weak關(guān)鍵字表明這是一個弱引用。
在實例的生命周期中，如果某些時候引用沒有值，那么弱引用可以阻止循環(huán)強引用。如果引用總是有值，則可以使用無主引用，在無主引用中有描述。在上面Apartment的例子中，一個公寓的生命周期中，有時是沒有“居民”的，因此適合使用弱引用來解決循環(huán)強引用。
注意: 弱引用必須被聲明為變量，表明其值能在運行時被修改。弱引用不能被聲明為常量。
因為弱引用可以沒有值，你必須將每一個弱引用聲明為可選類型。可選類型是在 Swift 語言中推薦的用來表示可能沒有值的類型。
因為弱引用不會保持所引用的實例，即使引用存在，實例也有可能被銷毀。因此，ARC 會在引用的實例被銷毀后自動將其賦值為nil。你可以像其他可選值一樣，檢查弱引用的值是否存在，你永遠也不會遇到被銷毀了而不存在的實例。
下面的例子跟上面Person和Apartment的例子一致，但是有一個重要的區(qū)別。這一次，Apartment的tenant屬性被聲明為弱引用：
class Person {
let name: String
init(name: String) { self.name = name }
var apartment: Apartment?
deinit { println("\(name) is being deinitialized") }
}
class Apartment {
let number: Int
init(number: Int) { self.number = number }
weak var tenant: Person?
deinit { println("Apartment #\(number) is being deinitialized") }
}
然后跟之前一樣，建立兩個變量（john和number73）之間的強引用，并關(guān)聯(lián)兩個實例：
var john: Person? var number73: Apartment? john = Person(name: "John Appleseed") number73 = Apartment(number: 73) john!.apartment = number73 number73!.tenant = john
現(xiàn)在，兩個關(guān)聯(lián)在一起的實例的引用關(guān)系如下圖所示：
Person實例依然保持對Apartment實例的強引用，但是Apartment實例只是對Person實例的弱引用。這意味著當你斷開john變量所保持的強引用時，再也沒有指向Person實例的強引用了：
由于再也沒有指向Person實例的強引用，該實例會被銷毀：
john = nil // prints "John Appleseed is being deinitialized"
唯一剩下的指向Apartment實例的強引用來自于變量number73。如果你斷開這個強引用，再也沒有指向Apartment實例的強引用了：
由于再也沒有指向Apartment實例的強引用，該實例也會被銷毀：
number73 = nil // prints "Apartment #73 is being deinitialized"
上面的兩段代碼展示了變量john和number73在被賦值為nil后，Person實例和Apartment實例的析構(gòu)函數(shù)都打印出“銷毀”的信息。這證明了引用循環(huán)被打破了。
無主引用
和弱引用類似，無主引用不會牢牢保持住引用的實例。和弱引用不同的是，無主引用是永遠有值的。因此，無主引用總是被定義為非可選類型（non-optional type）。你可以在聲明屬性或者變量時，在前面加上關(guān)鍵字unowned表示這是一個無主引用。
由于無主引用是非可選類型，你不需要在使用它的時候?qū)⑺归_。無主引用總是可以被直接訪問。不過 ARC 無法在實例被銷毀后將無主引用設(shè)為nil，因為非可選類型的變量不允許被賦值為nil。
注意: 如果你試圖在實例被銷毀后，訪問該實例的無主引用，會觸發(fā)運行時錯誤。使用無主引用，你必須確保引用始終指向一個未銷毀的實例。
還需要注意的是如果你試圖訪問實例已經(jīng)被銷毀的無主引用，程序會直接崩潰，而不會發(fā)生無法預期的行為。所以你應當避免這樣的事情發(fā)生。
下面的例子定義了兩個類，Customer和CreditCard，模擬了銀行客戶和客戶的信用卡。這兩個類中，每一個都將另外一個類的實例作為自身的屬性。這種關(guān)系會潛在的創(chuàng)造循環(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實例。這樣可以確保當創(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 { println("\(name) is being deinitialized") }
}
class CreditCard {
let number: Int
unowned let customer: Customer
init(number: Int, customer: Customer) {
self.number = number
self.customer = customer
}
deinit { println("Card #\(number) is being deinitialized") }
}
下面的代碼片段定義了一個叫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的無主引用，當你斷開john變量持有的強引用時，再也沒有指向Customer實例的強引用了：
由于再也沒有指向Customer實例的強引用，該實例被銷毀了。其后，再也沒有指向CreditCard實例的強引用，該實例也隨之被銷毀了：
john = nil // prints "John Appleseed is being deinitialized" // prints "Card #1234567890123456 is being deinitialized"
最后的代碼展示了在john變量被設(shè)為nil后Customer實例和CreditCard實例的構(gòu)造函數(shù)都打印出了“銷毀”的信息。
無主引用以及隱式解析可選屬性
上面弱引用和無主引用的例子涵蓋了兩種常用的需要打破循環(huán)強引用的場景。
Person和Apartment的例子展示了兩個屬性的值都允許為nil，并會潛在的產(chǎn)生循環(huán)強引用。這種場景最適合用弱引用來解決。
Customer和CreditCard的例子展示了一個屬性的值允許為nil，而另一個屬性的值不允許為nil，并會潛在的產(chǎn)生循環(huán)強引用。這種場景最適合通過無主引用來解決。
然而，存在著第三種場景，在這種場景中，兩個屬性都必須有值，并且初始化完成后不能為nil。在這種場景中，需要一個類使用無主屬性，而另外一個類使用隱式解析可選屬性。
這使兩個屬性在初始化完成后能被直接訪問（不需要可選展開），同時避免了循環(huán)引用。這一節(jié)將為你展示如何建立這種關(guān)系。
下面的例子定義了兩個類，Country和City，每個類將另外一個類的實例保存為屬性。在這個模型中，每個國家必須有首都，而每一個城市必須屬于一個國家。為了實現(xiàn)這種關(guān)系，Country類擁有一個capitalCity屬性，而City類有一個country屬性：
class Country {
let name: String
let 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屬性的默認值為nil，但是不需要展開他的值就能訪問它。（在隱式解析可選類型中有描述）
由于capitalCity默認值為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")
println("\(country.name)'s capital city is called \(country.capitalCity.name)")
// prints "Canada's capital city is called Ottawa"
在上面的例子中，使用隱式解析可選值的意義在于滿足了兩個類構(gòu)造函數(shù)的需求。capitalCity屬性在初始化完成后，能像非可選值一樣使用和存取同時還避免了循環(huán)強引用。
閉包引起的循環(huán)強引用
前面我們看到了循環(huán)強引用環(huán)是在兩個類實例屬性互相保持對方的強引用時產(chǎn)生的，還知道了如何用弱引用和無主引用來打破循環(huán)強引用。
循環(huán)強引用還會發(fā)生在當你將一個閉包賦值給類實例的某個屬性，并且這個閉包體中又使用了實例。這個閉包體中可能訪問了實例的某個屬性，例如self.someProperty，或者閉包中調(diào)用了實例的某個方法，例如self.someMethod。這兩種情況都導致了閉包 “捕獲" self，從而產(chǎn)生了循環(huán)強引用。
循環(huán)強引用的產(chǎn)生，是因為閉包和類相似，都是引用類型。當你把一個閉包賦值給某個屬性時，你也把一個引用賦值給了這個閉包。實質(zhì)上，這跟之前的問題是一樣的－兩個強引用讓彼此一直有效。但是，和兩個類實例不同，這次一個是類實例，另一個是閉包。
Swift 提供了一種優(yōu)雅的方法來解決這個問題，稱之為閉包占用列表（closuer capture list）。同樣的，在學習如何用閉包占用列表破壞循環(huán)強引用之前，先來了解一下循環(huán)強引用是如何產(chǎn)生的，這對我們是很有幫助的。
下面的例子為你展示了當一個閉包引用了self后是如何產(chǎn)生一個循環(huán)強引用的。例子中定義了一個叫HTMLElement的類，用一種簡單的模型表示 HTML 中的一個單獨的元素：
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 {
println("\(name) is being deinitialized")
}
}
HTMLElement類定義了一個name屬性來表示這個元素的名稱，例如代表段落的"p"，或者代表換行的"br"。HTMLElement還定義了一個可選屬性text，用來設(shè)置和展現(xiàn) HTML 元素的文本。
除了上面的兩個屬性，HTMLElement還定義了一個lazy屬性asHTML。這個屬性引用了一個閉包，將name和text組合成 HTML 字符串片段。該屬性是() -> String類型，或者可以理解為“一個沒有參數(shù)，返回String的函數(shù)”。
默認情況下，閉包賦值給了asHTML屬性，這個閉包返回一個代表 HTML 標簽的字符串。如果text值存在，該標簽就包含可選值text；如果text不存在，該標簽就不包含文本。對于段落元素，根據(jù)text是"some text"還是nil，閉包會返回
<p>some text</p>
或者
可以像實例方法那樣去命名、使用asHTML屬性。然而，由于asHTML是閉包而不是實例方法，如果你想改變特定元素的 HTML 處理的話，可以用自定義的閉包來取代默認值。
注意:
asHTML聲明為lazy屬性，因為只有當元素確實需要處理為HTML輸出的字符串時，才需要使用asHTML。也就是說，在默認的閉包中可以使用self，因為只有當初始化完成以及self確實存在后，才能訪問lazy屬性。
HTMLElement類只提供一個構(gòu)造函數(shù)，通過name和text（如果有的話）參數(shù)來初始化一個元素。該類也定義了一個析構(gòu)函數(shù)，當HTMLElement實例被銷毀時，打印一條消息。
下面的代碼展示了如何用HTMLElement類創(chuàng)建實例并打印消息。
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world") println(paragraph!.asHTML()) // prints"hello, world"
注意:
上面的paragraph變量定義為可選HTMLElement，因此我們可以賦值nil給它來演示循環(huán)強引用。
不幸的是，上面寫的HTMLElement類產(chǎn)生了類實例和asHTML默認值的閉包之間的循環(huán)強引用。循環(huán)強引用如下圖所示：
實例的asHTML屬性持有閉包的強引用。但是，閉包在其閉包體內(nèi)使用了self（引用了self.name和self.text），因此閉包捕獲了self，這意味著閉包又反過來持有了HTMLElement實例的強引用。這樣兩個對象就產(chǎn)生了循環(huán)強引用。（更多關(guān)于閉包捕獲值的信息，請參考值捕獲）。
注意:
雖然閉包多次使用了self，它只捕獲HTMLElement實例的一個強引用。
如果設(shè)置paragraph變量為nil，打破它持有的HTMLElement實例的強引用，HTMLElement實例和它的閉包都不會被銷毀，也是因為循環(huán)強引用：
paragraph = nil
注意HTMLElementdeinitializer中的消息并沒有別打印，證明了HTMLElement實例并沒有被銷毀。
解決閉包引起的循環(huán)強引用
在定義閉包時同時定義捕獲列表作為閉包的一部分，通過這種方式可以解決閉包和類實例之間的循環(huán)強引用。捕獲列表定義了閉包體內(nèi)捕獲一個或者多個引用類型的規(guī)則。跟解決兩個類實例間的循環(huán)強引用一樣，聲明每個捕獲的引用為弱引用或無主引用，而不是強引用。應當根據(jù)代碼關(guān)系來決定使用弱引用還是無主引用。
注意:
Swift 有如下要求：只要在閉包內(nèi)使用self的成員，就要用self.someProperty或者self.someMethod（而不只是someProperty或someMethod）。這提醒你可能會不小心就捕獲了self。
定義捕獲列表
捕獲列表中的每個元素都是由weak或者unowned關(guān)鍵字和實例的引用（如self或someInstance）成對組成。每一對都在方括號中，通過逗號分開。
捕獲列表放置在閉包參數(shù)列表和返回類型之前：
@lazy var someClosure: (Int, String) -> String = {
[unowned self] (index: Int, stringToProcess: String) -> String in
// closure body goes here
}
如果閉包沒有指定參數(shù)列表或者返回類型，則可以通過上下文推斷，那么可以捕獲列表放在閉包開始的地方，跟著是關(guān)鍵字in：
@lazy var someClosure: () -> String = {
[unowned self] in
// closure body goes here
}
弱引用和無主引用
當閉包和捕獲的實例總是互相引用時并且總是同時銷毀時，將閉包內(nèi)的捕獲定義為無主引用。
相反的，當捕獲引用有時可能會是nil時，將閉包內(nèi)的捕獲定義為弱引用。弱引用總是可選類型，并且當引用的實例被銷毀后，弱引用的值會自動置為nil。這使我們可以在閉包內(nèi)檢查他們是否存在。
注意:
如果捕獲的引用絕對不會置為nil，應該用無主引用，而不是弱引用。
前面的HTMLElement例子中，無主引用是正確的解決循環(huán)強引用的方法。這樣編寫HTMLElement類來避免循環(huán)強引用：
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 {
println("\(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") println(paragraph!.asHTML()) // prints "<p>hello, world</p>"
使用捕獲列表后引用關(guān)系如下圖所示：
這一次，閉包以無主引用的形式捕獲self，并不會持有HTMLElement實例的強引用。如果將paragraph賦值為nil，HTMLElement實例將會被銷毀，并能看到它的析構(gòu)函數(shù)打印出的消息。
paragraph = nil // prints "p is being deinitialized"
QQ交談
在線咨詢
渝公網(wǎng)安備
50010702500608號
客服熱線