[自我]如何在Swift上工作？它的工作原理类似于[无主自我]或强引用

我知道[软弱的自我]和[无主的自我]，但我不知道[自我]

它是如何工作的

[self]=[unowned self] 或

---

[self]=strong引用

通过捕获子句捕获变量：

var closure = { [x] in x.doSomething() }

将创建对x在创建闭包时引用的值的强捕获。见最后的例子

如果您没有像中那样使用capture子句

var closure = { x.doSomething() }

这将创建对x在执行闭包时引用的值的强引用

这就是说，捕获

[self]

会创建一个强引用，但是完全没有必要，除非您预期

self

在某个时间点发生变化（这是非常不寻常的）

---

例子

class-ValueClass{
变量值：字符串
init（v:String）{value=v}
func info（）{print（\（value）”）}
deinit{print（“deinit:\（value）”）}
}
如果（1==1）{
打印（“>>无捕获条款”）
var a:ValueClass？=ValueClass（“a”）
让闭包={a！=nil？a！.info（）：print（“a为nil”）}
a=ValueClass（“更改的a”）/“删除：a”
closure（）/“a为零”
打印（“>强捕获子句”）
var b:ValueClass？=ValueClass（“b”）
let closure={[b]在b！=nil？b！.info（）：print（“b是nil”）}
b=价值等级（“变更b”）
闭包（）/“b”
打印（“>弱捕获子句”）
var c:ValueClass？=ValueClass（“c”）
让闭包={c！=nil？c！.info（）：print（“c是nil”）}
c=ValueClass（“更改的c”）/“删除：c”
闭包（）/“c为零”
打印（“>无主捕获条款”）
变量d:ValueClass？=ValueClass（“d”）
let closure={[unowned]在d！=nil？d！.info（）：print（“d是nil”）}
d=ValueClass（“已更改的d”）/“数据单位：d”
closure（）//错误：执行被中断，原因：信号SIGABRT。
打印（“
class ValueClass {
    var value:String
    
    init (_ v:String)   { value = v }
    
    func info()         { print("\(value)") }
    deinit              { print ("deinit: \(value)") }
}

if (1==1) {
    print (">> No capture clause")
    var a:ValueClass? = ValueClass("a")
    let closure = { a != nil ? a!.info() : print("a is nil") }
    a = ValueClass("changed a")     // "deinit: a"
    closure()   // "a is nil"
    print ("<< done")
}// "deinit: changed a"

print ("------------------------------")

if (1==1) {
    print (">> strong capture clause")
    var b:ValueClass? = ValueClass("b")
    let closure = { [b] in b != nil ? b!.info() : print("b is nil") }
    b = ValueClass("changed b")
    closure()                   // "b"
    print ("<< done")
}                               // "deinit: b"; "deinit: changed b"

print ("------------------------------")

if (1==1) {
    print (">> weak capture clause")
    var c:ValueClass? = ValueClass("c")
    let closure = { [weak c] in c != nil ? c!.info() : print("c is nil") }
    c = ValueClass("changed c")     // "deinit: c"
    closure()                       // "c is nil"
    print ("<< done")
}                                   // "deinit: changed c"

print ("------------------------------")

if (1==1) {
    print (">> unowned capture clause")
    var d:ValueClass? = ValueClass("d")
    let closure = { [unowned d] in d != nil ? d!.info() : print("d is nil") }
    d = ValueClass("changed d")     // "deinit: d"
    closure()   // error: Execution was interrupted, reason: signal SIGABRT.
    print ("<< done")
}

>> No capture clause
deinit: a
changed a
<< done
deinit: changed a
------------------------------
>> strong capture clause
b
<< done
deinit: b
deinit: changed b
------------------------------
>> weak capture clause
deinit: c
c is nil
<< done
deinit: changed c
------------------------------
>> unowned capture clause
deinit: d

(CRASH)