如何正确处理带有参数的 Swift 块中的弱自我

Question

在我的TextViewTableViewCell 中，我有一个变量来跟踪一个块和一个用于传递和分配块的配置方法。
这是我的TextViewTableViewCell 课程：

//
//  TextViewTableViewCell.swift
//

import UIKit

class TextViewTableViewCell: UITableViewCell, UITextViewDelegate {

    @IBOutlet var textView : UITextView

    var onTextViewEditClosure : ((text : String) -> Void)?

    func configure(#text: String?, onTextEdit : ((text : String) -> Void)) {
        onTextViewEditClosure = onTextEdit
        textView.delegate = self
        textView.text = text
    }

    // #pragma mark - Text View Delegate

    func textViewDidEndEditing(textView: UITextView!) {
        if onTextViewEditClosure {
            onTextViewEditClosure!(text: textView.text)
        }
    }
}

当我在cellForRowAtIndexPath方法中使用configure方法时，如何在我传入的块中正确使用weak self。
这是没有弱自我的我所拥有的：

let myCell = tableView.dequeueReusableCellWithIdentifier(textViewCellIdenfitier) as TextViewTableViewCell
myCell.configure(text: body, onTextEdit: {(text: String) in
   // THIS SELF NEEDS TO BE WEAK  
   self.body = text
})
cell = bodyCell

更新：我得到以下使用[weak self]：

let myCell = tableView.dequeueReusableCellWithIdentifier(textViewCellIdenfitier) as TextViewTableViewCell
myCell.configure(text: body, onTextEdit: {[weak self] (text: String) in
        if let strongSelf = self {
             strongSelf.body = text
        }
})
cell = myCell

当我执行[unowned self] 而不是[weak self] 并取出if 语句时，应用程序崩溃。关于如何与[unowned self] 一起工作的任何想法？

Answer 1

如果 self 在闭包中可以为 nil，请使用 [weak self]。

如果 self 在闭包中永远不会为零，请使用 [unowned self]。

如果当你使用 [unowned self] 时它崩溃了，我猜想在那个闭包的某个时刻 self 是 nil ，这就是为什么你必须使用 [weak self] 代替。

我真的很喜欢手册中关于在闭包中使用 strong、weak 和 unowned 的整个部分：

https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html

注意：我使用术语 closure 而不是 block 这是较新的 Swift 术语：

Difference between block (Objective C) and closure (Swift) in ios

Answer 2

在闭包中将[unowned self] 放在(text: String)... 之前。这称为捕获列表，并将所有权说明放在闭包中捕获的符号上。

Answer 3

**为 Swift 4.2 编辑：

正如@Koen 所说，swift 4.2 允许：

guard let self = self else {
   return // Could not get a strong reference for self :`(
}

// Now self is a strong reference
self.doSomething()

P.S.：由于我有一些赞成票，我想推荐有关 escaping closures 的阅读。

已编辑：正如@tim-vermeulen 评论的那样，Chris Lattner 在 2016 年 1 月 22 日星期五 19:51:29 CST 上说，这个技巧不应该用在自己身上，所以请不要使用它。检查来自@gbk 的非转义闭包信息和捕获列表答案。**

对于那些在捕获列表中使用 [weak self] 的人，请注意 self 可能为 nil，所以我要做的第一件事是使用保护语句检查它

guard let `self` = self else {
   return
}
self.doSomething()

如果您想知道 self 周围的引号是什么，这是在闭包内使用 self 而无需将名称更改为 this、weakSelf 的专业技巧或其他。

Answer 4

编辑：参考 LightMan 的更新解决方案

见LightMan's solution。到目前为止，我一直在使用：

input.action = { [weak self] value in
    guard let this = self else { return }
    this.someCall(value) // 'this' isn't nil
}

或者：

input.action = { [weak self] value in
    self?.someCall(value) // call is done if self isn't nil
}

如果是推断的，通常不需要指定参数类型。

如果没有参数或在闭包中将其称为$0，则可以完全省略该参数：

input.action = { [weak self] in
    self?.someCall($0) // call is done if self isn't nil
}

只是为了完整性；如果您将闭包传递给函数并且参数不是@escaping，则不需要weak self：

[1,2,3,4,5].forEach { self.someCall($0) }

Answer 5

使用Capture list

定义捕获列表

捕获列表中的每个项目都是弱或无主的配对 关键字引用类实例（如 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
}

additional explanations

Answer 6

从 swift 4.2 开始? 我们可以做到：

_ = { [weak self] value in
    guard let self = self else { return }
    print(self) //? will never be nil
}()

Answer 7

斯威夫特 4.2

let closure = { [weak self] (_ parameter:Int) in
    guard let self = self else { return }

    self.method(parameter)
}

https://github.com/apple/swift-evolution/blob/master/proposals/0079-upgrade-self-from-weak-to-strong.md

Answer 8

您可以在捕获列表中的块参数之前使用 [weak self] 或 [unowned self]。捕获列表是可选语法。

[unowned self] 在这里工作得很好，因为单元格永远不会为零。否则你可以使用[weak self]

Answer 9

从Swift 5.3 开始，如果在in 之前通过[self]，则不必在结束时解开self。

在this swift doc中引用someFunctionWithEscapingClosure { [self] in x = 100 }

Answer 10

如果你崩溃了，那么你可能需要 [weak self]

我的猜测是你正在创建的块仍然以某种方式连接起来。

创建一个 prepareForReuse 并尝试清除其中的 onTextViewEditClosure 块。

func prepareForResuse() {
   onTextViewEditClosure = nil
   textView.delegate = nil
}

看看这是否能防止崩溃。 （这只是一个猜测）。

Answer 11

[Closure and strong reference cycles]

如您所知，Swift 的闭包可以捕获实例。这意味着您可以在闭包内使用self。特别是escaping closure^[About]可以创建一个strong reference cycle^[About]。顺便说一句，您必须在escaping closure 中明确使用self。

Swift 闭包具有Capture List 功能，可以避免这种情况并打破引用循环，因为对捕获的实例没有强引用。捕获列表元素是一对weak/unowned 和对类或变量的引用。

例如

class A {
    private var completionHandler: (() -> Void)!
    private var completionHandler2: ((String) -> Bool)!
    
    func nonescapingClosure(completionHandler: () -> Void) {
        print("Hello World")
    }
    
    func escapingClosure(completionHandler: @escaping () -> Void) {
        self.completionHandler = completionHandler
    }
    
    func escapingClosureWithPArameter(completionHandler: @escaping (String) -> Bool) {
        self.completionHandler2 = completionHandler
    }
}

class B {
    var variable = "Var"
    
    func foo() {
        let a = A()
        
        //nonescapingClosure
        a.nonescapingClosure {
            variable = "nonescapingClosure"
        }
        
        //escapingClosure
        //strong reference cycle
        a.escapingClosure {
            self.variable = "escapingClosure"
        }
        
        //Capture List - [weak self]
        a.escapingClosure {[weak self] in
            self?.variable = "escapingClosure"
        }
        
        //Capture List - [unowned self]
        a.escapingClosure {[unowned self] in
            self.variable = "escapingClosure"
        }
        
        //escapingClosureWithPArameter
        a.escapingClosureWithPArameter { [weak self] (str) -> Bool in
            self?.variable = "escapingClosureWithPArameter"
            return true
        }
    }
}

• weak - 更可取的是，在可能时使用它
• unowned - 当您确定实例所有者的生命周期大于闭包时使用它

[weak vs unowned]