Swift 1.0文件翻譯：TimothyYe
Swift 1.0文件校對：Hawstein Swift 2.0文件校對及翻譯潤色：Channe

PS：之前1.0版中文版看不懂地方在對比英文版後就懂了，還是之前翻譯的不夠準確啊。這次參與Swift 2.0文件ARC章節的校對翻譯，順便潤色一下部分翻譯，以便大家更好的理解原文的意思。

自動引用計數

---

本頁包含內容：

• 自動引用計數的工作機制
• 自動引用計數實踐
• 類例項之間的迴圈強引用
• 解決例項之間的迴圈強引用
• 閉包引起的迴圈強引用
• 解決閉包引起的迴圈強引用

Swift 使用自動引用計數（ARC）機制來跟蹤和管理你的應用程式的記憶體。通常情況下，Swift 的記憶體管理機制會一直起著作用，你無須自己來考慮記憶體的管理。ARC 會在類的例項不再被使用時，自動釋放其佔用的記憶體。

然而，在少數情況下，ARC 為了能幫助你管理記憶體，需要更多的關於你的程式碼之間關係的資訊。本章描述了這些情況，並且為你示範怎樣啟用 ARC 來管理你的應用程式的記憶體。

注意:
引用計數僅僅應用於類的例項。結構體和列舉型別是值型別，不是引用型別，也不是通過引用的方式儲存和傳遞。

自動引用計數的工作機制

當你每次建立一個類的新的例項的時候，ARC 會分配一大塊記憶體用來儲存例項的資訊。記憶體中會包含例項的型別資訊，以及這個例項所有相關屬性的值。

此外，當例項不再被使用時，ARC 釋放例項所佔用的記憶體，並讓釋放的記憶體能挪作他用。這確保了不再被使用的例項，不會一直佔用記憶體空間。

然而，當 ARC 收回和釋放了正在被使用中的例項，該例項的屬性和方法將不能再被訪問和呼叫。實際上，如果你試圖訪問這個例項，你的應用程式很可能會崩潰。

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

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

自動引用計數實踐

下面的例子展示了自動引用計數的工作機制。例子以一個簡單的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類有一個建構函式，此建構函式為例項的name屬性賦值，並列印一條訊息以表明初始化過程生效。Person類也擁有一個解構函式，這個解構函式會在例項被銷燬時列印一條訊息。

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

var reference1: Person?
var reference2: Person?
var reference3: Person?
複製程式碼

現在你可以建立Person類的新例項，並且將它賦值給三個變數中的一個：

reference1 = Person(name: "John Appleseed")
// prints "John Appleseed is being initialized”
複製程式碼

應當注意到當你呼叫Person類的建構函式的時候，"John Appleseed is being initialized”會被列印出來。由此可以確定建構函式被執行。

由於Person類的新例項被賦值給了reference1變數，所以reference1到Person類的新例項之間建立了一個強引用。正是因為這一個強引用，ARC 會保證Person例項被保持在記憶體中不被銷燬。

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

reference2 = reference1
reference3 = reference1
複製程式碼

現在這一個Person例項已經有三個強引用了。

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

reference1 = nil
reference2 = nil
複製程式碼

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

reference3 = nil
// prints "John Appleseed is being deinitialized"
複製程式碼

類例項之間的迴圈強引用

在上面的例子中，ARC 會跟蹤你所新建立的Person例項的引用數量，並且會在Person例項不再被需要時銷燬它。

然而，我們可能會寫出一個類例項的強引用數永遠不能變成0的程式碼。如果兩個類例項互相持有對方的強引用，因而每個例項都讓對方一直存在，就是這種情況。這就是所謂的迴圈強引用。

你可以通過定義類之間的關係為弱引用或無主引用，以替代強引用，從而解決迴圈強引用的問題。具體的過程在解決類例項之間的迴圈強引用中有描述。不管怎樣，在你學習怎樣解決迴圈強引用之前，很有必要了解一下它是怎樣產生的。

下面展示了一個不經意產生迴圈強引用的例子。例子定義了兩個類：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 number: Int
    init(number: Int) { self.number = number }
    var tenant: Person?
    deinit { print("Apartment #\(number) is being deinitialized") }
}
複製程式碼

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

類似的，每個Apartment例項有一個叫number，型別為Int的屬性，並有一個可選的初始化為nil的tenant屬性。tenant屬性是可選的，因為一棟公寓並不總是有居民。

這兩個類都定義了解構函式，用以在類例項被析構的時候輸出資訊。這讓你能夠知曉Person和Apartment的例項是否像預期的那樣被銷燬。

接下來的程式碼片段定義了兩個可選型別的變數john和number73，並分別被設定為下面的Apartment和Person的例項。這兩個變數都被初始化為nil，這正是可選的優點：

var john: Person?
var number73: Apartment?
複製程式碼

現在你可以建立特定的Person和Apartment例項並將賦值給john和number73變數：

john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)
複製程式碼

在兩個例項被建立和賦值後，下圖表現了強引用的關係。變數john現在有一個指向Person例項的強引用，而變數number73有一個指向Apartment例項的強引用：

現在你能夠將這兩個例項關聯在一起，這樣人就能有公寓住了，而公寓也有了房客。注意感嘆號是用來展開和訪問可選變數john和number73中的例項，這樣例項的屬性才能被賦值：

john!.apartment = number73
number73!.tenant = john
複製程式碼

在將兩個例項聯絡在一起之後，強引用的關係如圖所示：

不幸的是，這兩個例項關聯後會產生一個迴圈強引用。Person例項現在有了一個指向Apartment例項的強引用，而Apartment例項也有了一個指向Person例項的強引用。因此，當你斷開john和number73變數所持有的強引用時，引用計數並不會降為 0，例項也不會被 ARC 銷燬：

john = nil
number73 = nil
複製程式碼

注意，當你把這兩個變數設為nil時，沒有任何一個解構函式被呼叫。迴圈強引用會一直阻止Person和Apartment類例項的銷燬，這就在你的應用程式中造成了記憶體洩漏。

在你將john和number73賦值為nil後，強引用關係如下圖：

Person和Apartment例項之間的強引用關係保留了下來並且不會被斷開。

解決例項之間的迴圈強引用

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

弱引用和無主引用允許迴圈引用中的一個例項引用另外一個例項而不保持強引用。這樣例項能夠互相引用而不產生迴圈強引用。

對於生命週期中會變為nil的例項使用弱引用。相反地，對於初始化賦值後再也不會被賦值為nil的例項，使用無主引用。

弱引用

弱引用不會對其引用的例項保持強引用，因而不會阻止 ARC 銷燬被引用的例項。這個特性阻止了引用變為迴圈強引用。宣告屬性或者變數時，在前面加上weak關鍵字表明這是一個弱引用。

在例項的生命週期中，如果某些時候引用沒有值，那麼弱引用可以避免迴圈強引用。如果引用總是有值，則可以使用無主引用，在無主引用中有描述。在上面Apartment的例子中，一個公寓的生命週期中，有時是沒有“居民”的，因此適合使用弱引用來解決迴圈強引用。

注意:
弱引用必須被宣告為變數，表明其值能在執行時被修改。弱引用不能被宣告為常量。

因為弱引用可以沒有值，你必須將每一個弱引用宣告為可選型別。在 Swift 中，推薦使用可選型別描述可能沒有值的型別。

因為弱引用不會保持所引用的例項，即使引用存在，例項也有可能被銷燬。因此，ARC 會在引用的例項被銷燬後自動將其賦值為nil。你可以像其他可選值一樣，檢查弱引用的值是否存在，你將永遠不會訪問已銷燬的例項的引用。

下面的例子跟上面Person和Apartment的例子一致，但是有一個重要的區別。這一次，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 number: Int
    init(number: Int) { self.number = number }
    weak var tenant: Person?
    deinit { print("Apartment #\(number) is being deinitialized") }
}
複製程式碼

然後跟之前一樣，建立兩個變數（john和number73）之間的強引用，並關聯兩個例項：

var john: Person?
var number73: Apartment?

john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)

john!.apartment = number73
number73!.tenant = john
複製程式碼

現在，兩個關聯在一起的例項的引用關係如下圖所示：

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例項的解構函式都列印出“銷燬”的資訊。這證明了引用迴圈被打破了。

無主引用

和弱引用類似，無主引用不會牢牢保持住引用的例項。和弱引用不同的是，無主引用是永遠有值的。因此，無主引用總是被定義為非可選型別（non-optional type）。你可以在宣告屬性或者變數時，在前面加上關鍵字unowned表示這是一個無主引用。

由於無主引用是非可選型別，你不需要在使用它的時候將它展開。無主引用總是可以被直接訪問。不過 ARC 無法在例項被銷燬後將無主引用設為nil，因為非可選型別的變數不允許被賦值為nil。

注意:
如果你試圖在例項被銷燬後，訪問該例項的無主引用，會觸發執行時錯誤。使用無主引用，你必須確保引用始終指向一個未銷燬的例項。
還需要注意的是如果你試圖訪問例項已經被銷燬的無主引用，Swift 確保程式會直接崩潰，而不會發生無法預期的行為。所以你應當避免這樣的事情發生。

下面的例子定義了兩個類，Customer和CreditCard，模擬了銀行客戶和客戶的信用卡。這兩個類中，每一個都將另外一個類的例項作為自身的屬性。這種關係可能會造成迴圈強引用。

Customer和CreditCard之間的關係與前面弱引用例子中Apartment和Person的關係略微不同。在這個資料模型中，一個客戶可能有或者沒有信用卡，但是一張信用卡總是關聯著一個客戶。為了表示這種關係，Customer類有一個可選型別的card屬性，但是CreditCard類有一個非可選型別的customer屬性。

此外，只能通過將一個number值和customer例項傳遞給CreditCard建構函式的方式來建立CreditCard例項。這樣可以確保當建立CreditCard例項時總是有一個customer例項與之關聯。

由於信用卡總是關聯著一個客戶，因此將customer屬性定義為無主引用，用以避免迴圈強引用：

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位系統上都能足夠容納16位的卡號。

下面的程式碼片段定義了一個叫john的可選型別Customer變數，用來儲存某個特定客戶的引用。由於是可選型別，所以變數被初始化為nil。

var john: Customer?
複製程式碼

現在你可以建立Customer類的例項，用它初始化CreditCard例項，並將新建立的CreditCard例項賦值為客戶的card屬性。

john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
複製程式碼

在你關聯兩個例項後，它們的引用關係如下圖所示：

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

由於customer的無主引用，當你斷開john變數持有的強引用時，再也沒有指向Customer例項的強引用了：

由於再也沒有指向Customer例項的強引用，該例項被銷燬了。其後，再也沒有指向CreditCard例項的強引用，該例項也隨之被銷燬了：

john = nil
// prints "John Appleseed is being deinitialized"
// prints "Card #1234567890123456 is being deinitialized"
複製程式碼

最後的程式碼展示了在john變數被設為nil後Customer例項和CreditCard例項的建構函式都列印出了“銷燬”的資訊。

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

上面弱引用和無主引用的例子涵蓋了兩種常用的需要打破迴圈強引用的場景。

Person和Apartment的例子展示了兩個屬性的值都允許為nil，並會潛在的產生迴圈強引用。這種場景最適合用弱引用來解決。

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

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

這使兩個屬性在初始化完成後能被直接訪問（不需要可選展開），同時避免了迴圈引用。這一節將為你展示如何建立這種關係。

下面的例子定義了兩個類，Country和City，每個類將另外一個類的例項儲存為屬性。在這個模型中，每個國家必須有首都，每個城市必須屬於一個國家。為了實現這種關係，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
    }
}
複製程式碼

為了建立兩個類的依賴關係，City的建構函式有一個Country例項的引數，並且將例項儲存為country屬性。

Country的建構函式呼叫了City的建構函式。然而，只有Country的例項完全初始化完後，Country的建構函式才能把self傳給City的建構函式。（在兩段式構造過程中有具體描述）

為了滿足這種需求，通過在型別結尾處加上感嘆號（City!）的方式，將Country的capitalCity屬性宣告為隱式解析可選型別的屬性。這表示像其他可選型別一樣，capitalCity屬性的預設值為nil，但是不需要展開它的值就能訪問它。（在隱式解析可選型別中有描述）

由於capitalCity預設值為nil，一旦Country的例項在建構函式中給name屬性賦值後，整個初始化過程就完成了。這代表一旦name屬性被賦值後，Country的建構函式就能引用並傳遞隱式的self。Country的建構函式在賦值capitalCity時，就能將self作為引數傳遞給City的建構函式。

以上的意義在於你可以通過一條語句同時建立Country和City的例項，而不產生迴圈強引用，並且capitalCity的屬效能被直接訪問，而不需要通過感嘆號來展開它的可選值：

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"
複製程式碼

在上面的例子中，使用隱式解析可選值的意義在於滿足了兩個類建構函式的需求。capitalCity屬性在初始化完成後，能像非可選值一樣使用和存取同時還避免了迴圈強引用。

##閉包引起的迴圈強引用

前面我們看到了迴圈強引用是在兩個類例項屬性互相保持對方的強引用時產生的，還知道了如何用弱引用和無主引用來打破這些迴圈強引用。

迴圈強引用還會發生在當你將一個閉包賦值給類例項的某個屬性，並且這個閉包體中又使用了這個類例項。這個閉包體中可能訪問了例項的某個屬性，例如self.someProperty，或者閉包中呼叫了例項的某個方法，例如self.someMethod。這兩種情況都導致了閉包 “捕獲" self，從而產生了迴圈強引用。

迴圈強引用的產生，是因為閉包和類相似，都是引用型別。當你把一個閉包賦值給某個屬性時，你也把一個引用賦值給了這個閉包。實質上，這跟之前的問題是一樣的－兩個強引用讓彼此一直有效。但是，和兩個類例項不同，這次一個是類例項，另一個是閉包。

Swift 提供了一種優雅的方法來解決這個問題，稱之為閉包捕獲列表（closuer capture list）。同樣的，在學習如何用閉包捕獲列表破壞迴圈強引用之前，先來了解一下這裡的迴圈強引用是如何產生的，這對我們很有幫助。

下面的例子為你展示了當一個閉包引用了self後是如何產生一個迴圈強引用的。例子中定義了一個叫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屬性來表示這個元素的名稱，例如代表段落的"p"，或者代表換行的"br"。HTMLElement還定義了一個可選屬性text，用來設定和展現 HTML 元素的文字。

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

預設情況下，閉包賦值給了asHTML屬性，這個閉包返回一個代表 HTML 標籤的字串。如果text值存在，該標籤就包含可選值text；如果text不存在，該標籤就不包含文字。對於段落元素，根據text是"some text"還是nil，閉包會返回"<p>some text</p>"或者"<p />"。

可以像例項方法那樣去命名、使用asHTML屬性。然而，由於asHTML是閉包而不是例項方法，如果你想改變特定元素的 HTML 處理的話，可以用自定義的閉包來取代預設值。

注意:
asHTML宣告為lazy屬性，因為只有當元素確實需要處理為HTML輸出的字串時，才需要使用asHTML。也就是說，在預設的閉包中可以使用self，因為只有當初始化完成以及self確實存在後，才能訪問lazy屬性。

HTMLElement類只提供一個建構函式，通過name和text（如果有的話）引數來初始化一個元素。該類也定義了一個解構函式，當HTMLElement例項被銷燬時，列印一條訊息。

下面的程式碼展示瞭如何用HTMLElement類建立例項並列印訊息。

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

注意:
上面的paragraph變數定義為可選HTMLElement，因此我們可以賦值nil給它來演示迴圈強引用。

不幸的是，上面寫的HTMLElement類產生了類例項和asHTML預設值的閉包之間的迴圈強引用。迴圈強引用如下圖所示：

例項的asHTML屬性持有閉包的強引用。但是，閉包在其閉包體內使用了self（引用了self.name和self.text），因此閉包捕獲了self，這意味著閉包又反過來持有了HTMLElement例項的強引用。這樣兩個物件就產生了迴圈強引用。（更多關於閉包捕獲值的資訊，請參考值捕獲）。

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

如果設定paragraph變數為nil，打破它持有的HTMLElement例項的強引用，HTMLElement例項和它的閉包都不會被銷燬，也是因為迴圈強引用：

paragraph = nil
複製程式碼

注意HTMLElementdeinitializer中的訊息並沒有被列印，證明了HTMLElement例項並沒有被銷燬。

##解決閉包引起的迴圈強引用

在定義閉包時同時定義捕獲列表作為閉包的一部分，通過這種方式可以解決閉包和類例項之間的迴圈強引用。捕獲列表定義了閉包體內捕獲一個或者多個引用型別的規則。跟解決兩個類例項間的迴圈強引用一樣，宣告每個捕獲的引用為弱引用或無主引用，而不是強引用。應當根據程式碼關係來決定使用弱引用還是無主引用。

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

###定義捕獲列表

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

如果閉包有引數列表和返回型別，把捕獲列表放在它們前面：

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

如果閉包沒有指明引數列表或者返回型別，即它們會通過上下文推斷，那麼可以把捕獲列表和關鍵字in放在閉包最開始的地方：

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

###弱引用和無主引用

在閉包和捕獲的例項總是互相引用時並且總是同時銷燬時，將閉包內的捕獲定義為無主引用。

相反的，在被捕獲的引用可能會變為nil時，將閉包內的捕獲定義為弱引用。弱引用總是可選型別，並且當引用的例項被銷燬後，弱引用的值會自動置為nil。這使我們可以在閉包體內檢查它們是否存在。

注意:
如果被捕獲的引用絕對不會變為nil，應該用無主引用，而不是弱引用。

前面的HTMLElement例子中，無主引用是正確的解決迴圈強引用的方法。這樣編寫HTMLElement類來避免迴圈強引用：

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實現和之前的實現一致，除了在asHTML閉包中多了一個捕獲列表。這裡，捕獲列表是[unowned self]，表示“用無主引用而不是強引用來捕獲self”。

和之前一樣，我們可以建立並列印HTMLElement例項：

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

使用捕獲列表後引用關係如下圖所示：

這一次，閉包以無主引用的形式捕獲self，並不會持有HTMLElement例項的強引用。如果將paragraph賦值為nil，HTMLElement例項將會被銷燬，並能看到它的解構函式列印出的訊息。

paragraph = nil
// prints "p is being deinitialized"
複製程式碼