我们都喜欢关闭，不是吗？
闭包可以简化iOS开发人员的工作。好吧，如果这使我们工作变得容易，那为什么我要避免在Swift结构中使用闭包呢？ 原因是：内存泄漏和意外行为。
结构内存泄漏，可能吗？
结构是值类型，并且不可能发生内存泄漏。那句话是真的吗？我们已经有很多问题了。因此，让我们回顾一下Swift中的内存管理基础知识。
Swift中的基本类型分为两类。一种是“引用类型（Reference type）”，另一种是“值类型（Value type）”。通常，类是引用类型。另一方面，结构和枚举是值类型。
值类型（Value type）
值类型将数据直接存储在内存中。每个实例都有唯一的数据副本。将变量分配给现有变量后，将复制数据。值类型的分配在堆栈中完成。当值类型变量超出范围时，将发生内存的重新分配。
代码语言：javascript复制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（自动引用计数）处理引用类型变量的取消分配。
代码语言：javascript复制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
我想你开始想的是3和4最终打印的速度值都是——60，但是结果可能有点不一样：
代码语言：javascript复制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/
