我是否在这个嵌套的 function 中捕获自我？ 编译器不会发出警告

Question

我找不到任何有关此的官方文档，并且那里有不同的意见。

在以下情况下，一切都很好。

final class MyVC: UIViewController {
    
    var space: Space!
    
    private let tableView = MenuCategoriesTableView()
    
    private let tableViewHandler = MenuCategoriesTableViewHandler()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        tableView.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(tableView)
        NSLayoutConstraint.activate([
            tableView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            tableView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            tableView.topAnchor.constraint(equalTo: view.topAnchor),
            tableView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
        ])
        
        tableView.dataSource = tableViewHandler
        tableView.delegate = tableViewHandler
        
        tableViewHandler.didSelectRow = { [unowned self] option in
            let category = option.makeCategory()
            if category.items.count > 0 {
                let controller = MenuItemsViewController()
                controller.title = option.rawValue
                controller.space = self.space
                self.show(controller, sender: self)
            } else {
                // whatever
            }
        }
    }
}

但是，如果我进行以下更改，我不再需要使用unowned self ，但我仍然担心捕获自我。 我应该担心吗？ 如果不是，为什么？

final class MyVC: UIViewController {
    
    ...etc...
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        ...etc...
        
        func categorySelected(_ option: MenuOption, _ category: MenuCategory) {
            let controller = MenuItemsViewController()
            controller.title = option.rawValue
            controller.space = space
            show(controller, sender: self)
        }
        
        tableViewHandler.didSelectRow = { option in
            let category = option.makeCategory()
            if category.items.count > 0 {
                categorySelected(option, category)
            } else {
                // whatever
            }
        }
    }
}

Answer 1

当您将闭包分配给tableViewHandler.didSelectRow时，您分配给它并保留该闭包捕获的任何内容。

self保留tableViewHandler 。

因此，危险在于您将在闭包内引用self 。 如果你这样做，那就是一个保留周期。

这可能不是因为明确地提到了self 。 任何提及self的属性或方法都是对self的隐式引用。

---

好的，因此，让我们检查一下闭包。

您没有在闭包的主体中隐式或显式地提及self 。 但是，您确实调用了本地方法categorySelected 。 因此，您捕获此方法。

并且categorySelected确实提到了self 。 因此，它捕获self （因为每个 function 都是一个闭包）。

因此存在一个潜在的保留周期，您应该继续说unowned self以防止保留周期。

（我认为编译器在这里无法通过警告保留周期来帮助您；这太复杂了。这是您必须通过人为原因解决的问题。）

Answer 2

我做了一些调查，如果你使用引用self的内部 function ，你确实会得到一个保留周期。

这是一个例子：

typealias ClosureType = () -> ()
class Test {
    var closure:ClosureType?
    let value = 42
    
    func setClosure1() {
        self.closure = {
            print ("from setClosure1")
        }
    }
    
    func setClosure2() {
        self.closure = {
            [unowned self] in
            let v = self.value
            print ("from setClosure2 - value: \(v)")
        }
    }
    
    func setClosure3() {
        func innerFunc() {
            // [unowned self] in  // not allowed, compile error (sometimes even crashes)
            let v = value
            print ("value: \(v)")
        }
        self.closure = {
            [unowned self] in   // compiler warning: "Capture [self] was never used"
            print ("from setClosure3")
            innerFunc()
        }
    }

    deinit {
        print ("Deinit")
    }
}

如果您使用setClosure1 (trivial) 或setClosure2 (capture 子句)，则不会发生保留循环：

if (1==1) {
    let t = Test()
    t.setClosure1()
    t.closure?()
}  // deinit called here

但是如果你调用setClosure3 ， deinit将不会被调用：

if (1==1) {
    let t = Test()
    t.setClosure3()
    t.closure?()
}  // deinit NOT called here

没有直接的方法可以解决这个问题； 如您所见，在内部 function 中使用[unowned self]会导致编译器错误，在setClosure3中使用它会导致警告。

不过，有一种方法可以解决这个问题 - 您可以使用第二个闭包，而不是使用内部 function，您可以在其中指定[unowned self]捕获子句：

    func setClosure4() {
        let innerClosure:ClosureType = {
            [unowned self] in
            let v = self.value
            print ("value: \(v)")
        }
        self.closure = {
            print ("from setClosure4")
            innerClosure()
        }
    }

// ...

if (1==1) {
    let t = Test()
    t.setClosure4()
    t.closure?()
}  // deinit called here

结论：Swift 应该允许内部函数中的捕获子句。