我们都喜欢闭包，不是吗？

闭包可以简化iOS开发人员的工作。好吧，如果这使我们工作变得容易，那为什么我要避免在Swift结构体中使用闭包呢？

原因是：内存泄漏和意外行为。

结构体内存泄漏，可能吗？

结构体是值类型，并且不可能发生内存泄漏。这句话是真的吗？我们已经有很多问题了。因此，让我们回顾一下Swift中的内存管理基础知识。

Swift中的基本类型分为两类。一种是“引用类型（Reference type）”，另一种是“值类型（Value type）”。通常，类是引用类型。另一方面，结构体和枚举是值类型。

值类型（Value type）

值类型将数据直接存储在内存中。每个实例都有唯一的数据副本。将变量分配给现有变量后，将复制数据。值类型的分配在堆栈中完成。当值类型变量超出范围时，将发生内存的重新分配。

struct Person {
    var name : String
}
var oldPerson = Person(name: "韦弦zhy")
var newPerson = oldPerson
newPerson.name = "Swift Struct"
print(oldPerson.name)
print(newPerson.name)

-------
Output:
韦弦zhy
Swift Struct
-------

我们可以看到，更改newPerson的值不会更改oldPerson的值。这就是值类型的工作方式。

引用类型（Reference type）

引用类型在初始化时保留对数据的引用（即指针）。只要将变量分配给现有引用类型，该引用就在变量之间共享。引用类型的分配在堆中完成。ARC（自动引用计数）处理引用类型变量的取消分配。

class Person {
    var name: String
    init(withName name: String){
        self.name = name
    }
}
var oldPerson = Person(withName: "韦弦zhy")
var newPerson = oldPerson
newPerson.name = "Swift Struct"
print(oldPerson.name)
print(newPerson.name)


------
Output
Swift Struct
Swift Struct
------

我们可以看到更改oldPerson变量反映了newPerson变量中的更改。这就是引用类型的工作方式。通常，在引用类型中会发生内存泄漏。在大多数情况下，它以循环引用（retain cycles）的形式出现。
因此，如果引用类型是导致内存泄漏的原因，那么我们可以将值类型用于所有情况。那就应该解决问题。
不幸的是，这种情况并非如此。有时，结构体和枚举可以被视为引用类型，这意味着循环引用（retain cycles）也可以在结构体和枚举中发生。

结构体中产生循环引用的罪魁祸首——闭包（Closures）

当您在结构中使用闭包时，闭包的行为就像一个引用类型，问题就从那里开始。闭包需要引用外部环境，以便在执行闭包主体时可以修改外部变量。
在使用类（Class）的情况下，我们可以使用[weak self]打破循环引用。当我们尝试对某个结构体执行此操作时，会出现以下编译器错误，'weak' may only be applied to class and class-bound protocol types, not 'struct name'，比如如下代码：

struct Car {
    var speed: Float = 0.0
    var increaseSpeed: (() -> ())?
}
var myCar = Car()
myCar.increaseSpeed = { //[weak myCar] in
    myCar.speed += 30
    // The retain cycle occurs here. We cannot use [weak myCar] as myCar is a value type.
    //'weak' may only be applied to class and class-bound protocol types, not 'Car'
}
myCar.increaseSpeed?()
print("1: My car's speed \n\(myCar.speed)")

var myNewCar = myCar
print("2: My new car's speed \n\(myNewCar.speed)")

myNewCar.increaseSpeed?()
print("3: My new car's speed \n\(myNewCar.speed)")

myCar.increaseSpeed?()
print("4: My car's speed \n\(myCar.speed)")

大胆猜测一下最终打印的结果

Swift - Closure - Struct

1: My car's speed 
30.0
2: My new car's speed 
30.0
3: My new car's speed 
30.0
4: My car's speed 
90.0

是的，是90！

原因解析：

结构体myNewCar是结构体myCar的部分副本。由于闭包及其环境无法完全复制，属性speed的值被复制了，但是myNewCar的属性increaseSpeed在捕获的环境变量中引用了myCar的increaseSpeed和myCar的speed。因此，myNewCar.increaseSpeed?()最终调用的是myCar的increaseSpeed，所以最终打印的值就是myCar的值变成了90。

这就是为什么Swift结构中的闭包很危险的原因。

直接的解决方案是，避免在值类型中使用闭包。如果要使用它们，则应格外小心，否则可能会导致意外结果。关于保留周期，打破它们的唯一方法是将变量myCar和myNewCar手动设置为nil。听起来并不理想，但是没有其他方法。

参考：

[1] https://ohmyswift.com/blog/2020/01/10/why-should-we-avoid-using-closures-in-swift-structs/
[2] https://github.com/Wolox/ios-style-guide/blob/master/rules/avoid-struct-closure-self.md
[3] https://www.objc.io/issues/16-swift/swift-classes-vs-structs/
[4] https://marcosantadev.com/capturing-values-swift-closures/

赏我一个赞吧~~~