相信大家都知道，閉包使用不當，會造成引用迴圈，從而造成App的記憶體洩露。但是有時候，看起來會造成引用迴圈的程式碼實際上並沒有造成引用迴圈。這個需要我們正確的區分。

【栗子1】請大家看看下面的程式碼，分析請看註釋：

class ClassA {
    let power =2
    var transform: (Int ->Int)?
    var dataArr = [1,2,3,4]
    deinit {
    print("ClassA例項被銷燬")
    }
}


var a: ClassA =ClassA()   // ClassA例項的引用計數為1
a.transform = {  numin
    returna.power * num   //閉包捕獲a, 則ClassA例項的引用計數 增加1，現在為2 ;同時，a.transform指向該閉包，閉包的引用計數為1
}
a.transform!(5)
a = ClassA()<span style="font-family: Arial, Helvetica, sans-serif;"> //將a重新賦值。原來的ClassA例項的引用計數減一。原來的ClassA例項的引用計數為1。</span>
 

       由此得出結論：執行的最後，原來的ClassA例項持有一個指向閉包的引用；閉包也持有一個指向原來ClassA例項的引用。從而造成引用迴圈。

似乎如此。如圖：

                                                       圖 1-1

       但是，當我們把這段程式碼拿到playground上執行，結果卻發現我們的判斷是錯誤的——最先建立的那個ClassA例項被正常銷燬了。為什麼會這樣呢？

       原因就是，閉包捕獲的是閉包外部變數的引用，是引用，是引用，重要的事情說3遍！如果那個變數本身是引用，那麼，閉包捕獲的就是那個引用的引用了。所以在這裡，閉包捕獲的是變數a的引用，並不是ClassA例項的引用。也就沒有造成引用迴圈。如圖

                                                       圖 1-2

         相信大家現在明白了吧。

【栗子2】接下來，大家看看這個程式碼：

class ClassA {
    let power =2
    lazyvar transform: (Int ->Int) = {num in num *self.power}
    var dataArr = [1,2,3,4]
    deinit {
    print("ClassA例項被銷燬")
    }
}

var a =ClassA()
a.transform(8)
a =ClassA()
 

       這段程式碼跟例子1的程式碼很相似。但是在閉包裡用的是self。在playground上執行，發現最開始的ClassA例項沒有被正常銷燬，這是由於其真正造成了記憶體洩露。為什麼呢？

       self，代表當前的例項。所以，在閉包中使用了self，使得閉包捕獲了當前例項的引用，從而持有了指向當前例項的引用。從而造成引用迴圈。如圖

                                                       圖 2-1

【栗子3】可能有人列印過閉包內外變數的地址，發現它們的地址是一樣的。如圖

                                                                                        圖 3-1

       當我們分別在閉包外和閉包內列印變數a的地址的時候，發現這兩個的地址一樣的。這個可以在inout關鍵字中一樣。如圖

                                                                                        圖 3-2

       swift 中，inout是將值傳遞給函式，在函式執行完後，將這個值替換掉原來的那個值。從而達到使用inout能起到引用傳遞修改值的效果。我們在函式內外都對實參的地址進行了列印，結果兩者是一摸一樣的。圖3-1中，閉包捕獲的引數跟外部的地址一樣，估計是蘋果做了些處理。

備註：本文下的Xcode的版本為7.3.1。