• 原文地址：Swift Arrays Holding Elements With Weak References
• 原文作者：Marco Santarossa
• 譯文出自：掘金翻譯計劃
• 譯者：zhangqippp
• 校對者：ZhangRuixiang，Danny1451

對元素持有弱引用的Swift陣列

在 iOS 開發中我們經常面臨一個問題：“用弱引用還是不用，這是一個問題。”。我們來看一下如何在陣列中使用弱引用。

概述

在本文中，我會談到記憶體管理但是不會解釋它，因為這不是本文的主題。官方文件是學習記憶體管理的一個好的起點。如果你有其它疑問，請留言，我會盡快給予回覆。

Array 是Swift中使用最多的集合。它會預設地對其元素持有強引用。 這種預設的行為在大多數時候都很有用，但是在某些場景下你可能想要使用弱引用。因此，蘋果公司給我們提供了一個 Array 的替代品：NSPointerArray，這個類對它的元素持有弱引用。

在開始研究這個類之前，我們先通過一個例子來了解為什麼我們需要使用它。

為什麼要使用弱引用？

舉個例子，我們有一個 ViewManager ，它有兩個 View 型別的屬性。在它的構造器中，我們把這些檢視新增到 Drawer 內部的一個陣列中，Drawer 使用這個陣列在其中的檢視內繪製一些內容。最後，我們還有一個 destroyViews 方法來銷燬這兩個 View：

class View { }

class Drawer {

    private let views: [View]

    init(views: [View]) {
        self.views = views
    }

    func draw() {
        // draw something in views
    }
}

class ViewManager {

    private var viewA: View? = View()
    private var viewB: View? = View()
    private var drawer: Drawer

    init() {
        self.drawer = Drawer(views: [viewA!, viewB!])
    }

    func destroyViews() {
        viewA = nil
        viewB = nil
    }
}複製程式碼

但是，destroyViews 方法並沒能銷燬這兩個檢視，因為 Drawer 內部的陣列依然對這些檢視保持著強引用。我們可以通過使用 NSPointerArray 來避免這個問題。

NSPointerArray

NSPointerArray 是 Array 的一個替代品，主要區別在於它不儲存物件而是儲存物件的指標（ UnsafeMutableRawPointer ）。

這種型別的陣列可以管理弱引用也可以管理強引用，取決於它是如何被初始化的。它提供兩個靜態方法以便我們使用不同的初始化方式：

let strongRefarray = NSPointerArray.strongObjects() // Maintains strong references
let weakRefarray = NSPointerArray.weakObjects() // Maintains weak references複製程式碼

我們需要一個弱引用的陣列，所以我們使用 NSPointerArray.weakObjects()。

現在，我們向陣列中新增一個新物件：

class MyClass { }

var array = NSPointerArray.weakObjects()

let obj = MyClass()
let pointer = Unmanaged.passUnretained(obj).toOpaque()
array.addPointer(pointer)複製程式碼

如果你覺得這樣使用指標很煩，你可以使用我寫的這個擴充套件，可以簡化 NSPointerArray 的使用：

extension NSPointerArray {
    func addObject(_ object: AnyObject?) {
        guard let strongObject = object else { return }

        let pointer = Unmanaged.passUnretained(strongObject).toOpaque()
        addPointer(pointer)
    }

    func insertObject(_ object: AnyObject?, at index: Int) {
        guard index < count, let strongObject = object else { return }

        let pointer = Unmanaged.passUnretained(strongObject).toOpaque()
        insertPointer(pointer, at: index)
    }

    func replaceObject(at index: Int, withObject object: AnyObject?) {
        guard index < count, let strongObject = object else { return }

        let pointer = Unmanaged.passUnretained(strongObject).toOpaque()
        replacePointer(at: index, withPointer: pointer)
    }

    func object(at index: Int) -> AnyObject? {
        guard index < count, let pointer = self.pointer(at: index) else { return nil }
        return Unmanaged<AnyObject>.fromOpaque(pointer).takeUnretainedValue()
    }

    func removeObject(at index: Int) {
        guard index < count else { return }

        removePointer(at: index)
    }
}複製程式碼

有了這個擴充套件類，你可以將前面的例子替換為：

var array = NSPointerArray.weakObjects()

let obj = MyClass()
array.addObject(obj)複製程式碼

如果你想清理這個陣列，把其中的物件都置為 nil，你可以呼叫 compact() 方法：

array.compact()複製程式碼

到了這裡，我們可以將上一小節 “為什麼要使用弱引用？” 中的例子重構為如下程式碼：

class View { }

class Drawer {

    private let views: NSPointerArray

    init(views: NSPointerArray) {
        self.views = views
    }

    func draw() {
        // draw something in views
    }
}

class ViewManager {

    private var viewA: View? = View()
    private var viewB: View? = View()
    private var drawer: Drawer

    init() {
        let array = NSPointerArray.weakObjects()
        array.addObject(viewA)
        array.addObject(viewB)
        self.drawer = Drawer(views: array)
    }

    func destroyViews() {
        viewA = nil
        viewB = nil
    }
}複製程式碼

注意:

1. 你可能已經注意到了 NSPointerArray 只儲存 AnyObject 的指標，這意味著你只能儲存類 —— 結構體和列舉都不行。你可以儲存帶有 class 關鍵字的協議：

protocolMyProtocol: class{}複製程式碼

1. 如果你想試用一下 NSPointerArray，我建議不要使用 Playground ，因為你可能因為引用計數問題得到一些奇怪的行為。使用一個簡單的 app 會更好。

備選方案

NSPointerArray 對於儲存物件和保持弱引用來說非常有用，但是它有一個問題：它不是型別安全的。

“非型別安全”，在此處的意思是編譯器無法無法推斷隱含在 NSPointerArray 內部的物件的型別，因為它使用的是 AnyObject 型物件的指標。因此，當你從陣列中獲取一個物件時，你需要把它轉成你所需要的型別：

if let firstObject=array.object(at:0)as?MyClass{// Cast to MyClass

    print("The first object is a MyClass")

}複製程式碼

object(at:) 方法來自我先前展示的 NSPointerArray 擴充套件類。

如果我們想使用一個型別安全的陣列替代品，我們就不能使用 NSPointerArray 了。

一個可行的方案是建立一個新類 WeakRef ，它帶有一個普通的weak屬性 value：

class WeakRef<T>whereT: AnyObject{

    private(set)weakvarvalue:T?

    init(value:T?){

        self.value=value

    }

}複製程式碼

private(set) 方法將 value 設定為只讀模式, 這樣就無法在類的外部設定它的值了。

然後，我們可以建立一組 WeakRef 物件，將你的 MyClass 物件儲存到它們的 value 屬性：

var array=[WeakRef<MyClass>]()



let obj=MyClass()

let weakObj=WeakRef(value:obj)

array.append(weakObj)複製程式碼

現在，我們擁有一個型別安全的陣列，其內部對你的 MyClass 物件持有弱引用。這種實現的壞處在於，我們必須在程式碼中多加一層（WeakRef），來用一種型別安全的方式包裹弱引用。

如果你想清理陣列，去除其中值為 nil 的物件，你可以使用下面的方法：

func compact(){

    array=array.filter{$0.value!=nil}

}複製程式碼

filter 返回一個其中元素滿足給定條件的新陣列。你可以在文件中獲取更多的資訊。

現在，我們可以將 “為什麼要使用弱引用？” 小節中的例子重構為如下程式碼：

class View { }

class Drawer {

    private let views: [WeakRef<View>]

    init(views: [WeakRef<View>]) {
        self.views = views
    }

    func draw() {
        // draw something in views
    }
}

class ViewManager {

    private var viewA: View? = View()
    private var viewB: View? = View()
    private var drawer: Drawer

    init() {
        var array = [WeakRef<View>]()
        array.append(WeakRef<View>(value: viewA))
        array.append(WeakRef<View>(value: viewB))
        self.drawer = Drawer(views: array)
    }

    func destroyViews() {
        viewA = nil
        viewB = nil
    }
}複製程式碼

使用型別別名的更簡潔的版本如下：

typealias WeakRefView = WeakRef<View>

class View { }

class Drawer {

    private let views: [WeakRefView]

    init(views: [WeakRefView]) {
        self.views = views
    }

    func draw() {
        // draw something in views
    }
}

class ViewManager {
    private var viewA: View? = View()
    private var viewB: View? = View()
    private var drawer: Drawer

    init() {
        var array = [WeakRefView]()
        array.append(WeakRefView(value: viewA))
        array.append(WeakRefView(value: viewB))
        self.drawer = Drawer(views: array)
    }

    func destroyViews() {
        viewA = nil
        viewB = nil
    }
}複製程式碼

Dictionary 和 Set

本文主要討論了 Array，如果你需要 Dictionary 的類似於 NSPointerArray 的替代品，你可以參考 NSMapTable，以及 Set 的替代品 NSHashTable。

如果你需要一個型別安全的 Dictionary/Set，你可以通過使用 WeakRef 物件來實現。

結論

你可能不會經常使用持有弱引用的陣列，但是這不是不去了解其實現原理的理由。在 iOS 開發中，記憶體管理是非常重要的，我們應該避免記憶體洩露，因為 iOS 沒有垃圾回收器。 ¯_(ツ)_/¯

---

掘金翻譯計劃 是一個翻譯優質網際網路技術文章的社群，文章來源為 掘金 上的英文分享文章。內容覆蓋 Android、iOS、React、前端、後端、產品、設計 等領域，想要檢視更多優質譯文請持續關注 掘金翻譯計劃。