一. 闭包表达式（Closure Expression）
在Swift中，可以通过func定义一个函数，也可以通过闭包表达式定义一个函数，闭包表达式和闭包是两回事
由于闭包表达式就是一个代码片段，所以需要有参数、返回值、函数体代码，所以闭包表达式的格式如下：
{
(参数列表) -> 返回值类型 in
函数体代码
}
通过func定义一个函数：
func sum(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
通过闭包表达式定义一个函数：
//通过闭包表达式定义一个函数，然后调用
var fn = {
(v1: Int, v2: Int) -> Int in
return v1 + v2
}
fn(10, 20) //闭包调用的时候默认不用写参数名称的
//通过闭包表达式定义一个函数，并且直接调用
{
(v1: Int, v2: Int) -> Int in
return v1 + v2
}(10, 20)
二. 闭包表达式的简写
//参数为两个Int变量、一个函数
func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {
print(fn(v1, v2))
}
//调用的时候
//什么都不省略，最后一个函数参数使用闭包表达式的形式
exec(v1: 10, v2: 20, fn: {
(v1: Int, v2: Int) -> Int in
return v1 + v2
})
//最后一个函数参数省略参数类型、返回值类型 (因为编译器能推断出来)
exec(v1: 10, v2: 20, fn: {
v1, v2 in return v1 + v2
})
//最后一个函数参数省略return
exec(v1: 10, v2: 20, fn: {
v1, v2 in v1 + v2
})
//超级简写：$0和$1代表闭包中的第一、二个参数
exec(v1: 10, v2: 20, fn: { $0 + $1 })
//终极简写：只用一个+
exec(v1: 10, v2: 20, fn: +)
三. 尾随闭包
如果将一个很长的闭包表达式作为函数的最后一个实参，使用尾随闭包可以增强函数的可读性。
尾随闭包是一个被书写在函数调用括号外面(后面)的闭包表达式。
func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {
print(fn(v1, v2))
}
//写成尾随闭包，增强函数的可读性
//$0和$1代表闭包中的第一、二个参数
exec(v1: 10, v2: 20) {
$0 + $1
}
如果闭包表达式是函数的唯一实参，而且使用了尾随闭包的语法，那就不需要在函数名后边写圆括号（因为没其他参数了，肯定可以省略圆括号）
func exec(fn: (Int, Int) -> Int) {
print(fn(1, 2))
}
exec(fn: { $0 + $1 }) //都不省略
exec() { $0 + $1 } //省略标签
exec { $0 + $1 } //省略标签和()
① 忽略参数
func exec(fn: (Int, Int) -> Int) {
print(fn(1, 2))
}
//用_忽略参数
exec { _,_ in 10 } //10
② 示例：数组的排序
sort函数要求传入一个(Element, Element) -> Bool类型的参数：
func sort(by areInIncreasingOrder: (Element, Element) -> Bool)
可以传入函数：
// 返回true: i1排在i2前面，返回false: i1排在i2后面
func cmp(i1: Int, i2: Int) -> Bool {
// 大的排在前面
return i1 > i2
}
var nums = [11, 2, 18, 6, 5, 68, 45]
nums.sort(by: cmp)
// [68, 45, 18, 11, 6, 5, 2]
也可以传入闭包表达式：
nums.sort(by: {
(i1: Int, i2: Int) -> Bool in
return i1 < i2
})
nums.sort(by: { i1, i2 in return i1 < i2 })
nums.sort(by: { i1, i2 in i1 < i2 })
nums.sort(by: { $0 < $1 })
nums.sort(by: <)
nums.sort() { $0 < $1 } //$0和$1代表闭包中的第一、二个参数
nums.sort { $0 < $1 } //[2, 5, 6, 11, 18, 45, 68]
四. 闭包（Closure）
1. 什么是闭包
网上有各种关于闭包的定义，个人觉得比较严谨的定义是：
Swift闭包：一个函数和它所捕获的变量\常量环境组合起来，称为闭包，可以把闭包想象成是一个类的实例对象。
一般指定义在函数内部的函数
一般它捕获的是外层函数的局部变量\常量
参考OC的block定义：block是封装了函数调用以及函数调用环境的OC对象。
闭包如下：
typealias Fn = (Int) -> Int
//func函数加上捕获的num变量组成闭包
func getFn() -> Fn {
var num = 0
func plus(_ i: Int) -> Int {
num += i
return num
}
return plus
} // 返回的plus和num变量形成了闭包
//闭包表达式加上捕获的num组成闭包
func getFn() -> Fn {
var num = 0
return {
num += $0
return num
}
}
var fn1 = getFn() //想象成创建了一个实例对象
var fn2 = getFn() //想象成再创建一个实例对象
fn1(1) // 1
fn1(3) // 4
fn1(5) // 9
fn2(2) // 2
fn2(4) // 6
fn2(6) // 12
解释如上代码：getFn函数调用的时候，getFn函数里面的num是在栈空间，在getFn函数调用完之前会将num变量拷贝到堆空间，返回的plus和堆空间的num变量形成了闭包，所以以后每次调用闭包的时候闭包里面的num变量一直都是刚开始捕获的那个值。(当getFn函数调用完的时候，栈空间的num变量就被销毁了)
可以把闭包想象成是一个类的实例对象：
- 内存在堆空间
- 捕获的局部变量\常量就是对象的成员(存储属性)
- 组成闭包的函数就是类内部定义的方法
使用类实现如下，是不是很像呢？
class Closure {
var num = 0
func plus(_ i: Int) -> Int {
num += i
return num
}
}
var cs1 = Closure()
var cs2 = Closure()
cs1.plus(1) // 1
cs1.plus(3) // 4
cs1.plus(5) // 9
cs2.plus(2) // 2
cs2.plus(4) // 6
cs2.plus(6) // 12
2. 闭包的本质
typealias Fn = (Int) -> Int
func getFn() -> Fn {
var num = 0
func plus(_ i: Int) -> Int {
num += i
return num
}
return plus
} // 返回的plus和num形成了闭包
var fn1 = getFn() //想象成创建了一个实例对象
var fn2 = getFn() //想象成再创建一个实例对象
fn1(1) // 1
fn1(3) // 4
fn1(5) // 9
fn2(2) // 2
fn2(4) // 6
fn2(6) // 12
print(MemoryLayout.size(ofValue: fn1)) //16
print(MemoryLayout.stride(ofValue: fn1)) //16
print(MemoryLayout.alignment(ofValue: fn1)) //8
下面结论都是MJ老师通过汇编一步一步验证的：
① 没捕获
当plus函数没有捕获外面变量，fn1占用16字节，前8字节存放的是plus函数地址，后8字节为空。
② 全局变量
如果num是全局变量，全局变量不会捕获到堆空间，捕获到堆空间的目的是保住num的命，全局变量在程序运行中一直活着，根本没必要捕获。这时候fn1占用16字节，前8字节存放的是plus函数地址，后8字节为空。
③ 捕获了
- 当plus函数捕获了外面变量，fn1就是个闭包，fn1占用16个字节，前8个字节存放的是plus函数地址，后8个字节存放的是堆空间的地址值(堆空间分配24字节，前8字节放类型信息，后8字节放引用计数，最后8字节放num，其实就相当于一个对象)。
- 执行fn1(1)、fn1(3)...最终会调用plus函数，调用plus函数的时候传入两个参数，一个是i，一个是堆空间的地址值，有了堆空间的地址值就能访问num进行一些运算了。
- fn2也是16字节，前8字节和fn1前8字节一样的，因为都是plus函数的地址值，但是后8字节和fn1不一样，因为堆空间的内存是重新分配的，所以堆空间的地址值不一样。
④ 如果将上面的num换成Person对象呢？
func testClosure() {
class Person {
var age: Int = 10
}
typealias Fn = (Int) -> Int
func getFn() -> Fn {
// 局部变量，对象类型
var person1 = Person()
var person2 = Person()
func plus(_ i: Int) -> Int {
person1.age += i
person2.age += i
return person1.age + person2.age
}
return plus
} // 返回的plus和num形成了闭包
var fn1 = getFn()
print(fn1(1)) // 10 + 1 + 10 + 1 = 22
print(fn1(3)) // 11 + 3 + 11 + 3 = 28
var fn2 = getFn()
print(fn2(2)) // 10 + 2 + 10 + 2 = 24
print(fn2(4)) // 12 + 4 + 12 + 4 = 32
}
testClosure()
由于我不会看汇编，猜测一下：
- fn1是个闭包，fn1会捕获person1和persn2，由于Person对象本来就在堆空间，所以如果plus函数捕获了Person对象，应该是将Person对象的指针保存到闭包fn1里面了。
- fn1占用32字节，前8个字节存放的是plus函数地址，后8个字节存放的是person1对象的指针，再后8字节存放的是person2对象的指针，最后8字节为空。
- plus函数内部会根据Person对象的修饰符(__strong、__weak、__unsafe_unretained)做出相应的操作，形成强引用(retain)或者弱引用，这样以后如果要使用Person对象，就直接通过闭包里面Person对象的指针访问就可以了。
- fn2和fn1类似......
3. 关于闭包练习
练习①：
typealias Fn = (Int) -> (Int, Int)
func getFns() -> (Fn, Fn) {
var num1 = 0
var num2 = 0
func plus(_ i: Int) -> (Int, Int) {
num1 += i
num2 += i << 1 //左移1就是乘以2
return (num1, num2)
}
func minus(_ i: Int) -> (Int, Int) {
num1 -= i
num2 -= i << 1 //左移1就是乘以2
return (num1, num2)
}
return (plus, minus)
}
let (p, m) = getFns()
p(5) // (5, 10)
m(4) // (1, 2)
p(3) // (4, 8)
m(2) // (2, 4)
上面的闭包中有两个变量num1、num2，两个函数plus、minus，现在的问题是两个函数是分别捕获num1、num2还是共同捕获num1、num2。
通过汇编分析可知，调用一次getFns()，num1、num2各分配一次堆空间，然后这两个堆空间给plus、minus函数共享。
其实，如果把闭包当成类就更容易理解了，num1、num2相当于类的成员变量，两个函数相当于类的成员函数，结果是一样的，如下：
class Closure {
var num1 = 0
var num2 = 0
func plus(_ i: Int) -> (Int, Int) {
num1 += i
num2 += i << 1
return (num1, num2)
}
func minus(_ i: Int) -> (Int, Int) {
num1 -= i
num2 -= i << 1
return (num1, num2)
}
}
var cs = Closure()
cs.plus(5) // (5, 10)
cs.minus(4) // (1, 2)
cs.plus(3) // (4, 8)
cs.minus(2) // (2, 4)
练习②：
var functions: [() -> Int] = []
for i in 1...3 {
functions.append { i }
//上面是尾随闭包(不接收参数返回i的函数，这个函数作为append的参数)
//和下面注释表示的是一个意思，三个myFunc()函数对应三个i
//func myFunc() -> Int {
// return i
//}
//functions.append(myFunc)
for f in functions {
print(f())
}
// 1
// 2
// 3
首先要看懂上面的尾随闭包。接下来分析为什么打印：1 2 3
分析汇编可知：上面的i捕获了三次(i == 1,i == 2,i == 3)，各分配一次堆空间，for循环里面的三个“myFunc()函数”分别访问对应的三个堆空间。
如果把上面的闭包想象成类就是下面这样：
class Closure {
var i: Int
init(_ i: Int) {
self.i = i
}
func get() -> Int {
return i
}
}
var clses: [Closure] = []
for i in 1...3 {
clses.append(Closure(i))
}
for cls in clses {
print(cls.get())
}
注意：
如果返回值是函数类型，那么参数的修饰要保持统一
func add(_ num: Int) -> (inout Int) -> Void {
func plus(v: inout Int) {
v += num
}
return plus
}
var num = 5
add(20)(&num)
print(num) //20 + 5 = 25
如上，add函数返回的函数类型要和plus函数的类型保持一致。
五. 自动闭包 @autoclosure
1. 延迟加载
为什么使用延迟加载？如下代码：
func getNumber() -> Int {
let a = 10
let b = 11
print("getNumber")
return a + b
}
func getFirstPositive(_ v1: Int, _ v2: Int) -> Int {
return v1 > 0 ? v1 : v2
}
getFirstPositive(10, getNumber())
结果打印：getNumber，说明getNumber会调用。
为什么getNumber会调用？因为指定了getFirstPositive函数的第二个参数是Int类型，但是你传进来的是函数调用，所以只有拿到函数调用的结果才知道第二个参数具体是多少。
上面既然第一个参数传入了10，大于0，那么getNumber()就没必要调用了，但是上面还是调用了，所以可以使用延迟加载减少不必要的调用。
如果我们将第二个参数改成不接收任何参数返回一个Int的函数(闭包表达式)：
func getFirstPositive(_ v1: Int, _ v2: () -> Int) -> Int {
return v1 > 0 ? v1 : v2()
}
//调用getFirstPositive函数
getFirstPositive(10, {
let a = 10
let b = 11
print("getNumber")
return a + b
})
传入10，打印空
传入-10，打印：getNumber
这样就实现了，需要调用第二个函数(闭包表达式)的时候才调用第二个函数，不需要的时候就不调用。( 比如一些网络请求啊，如果前面的符合条件就没必要进行请求了)
2. 由延迟加载引出自动闭包
// 如果第1个数大于0，返回第一个数。否则返回第2个数
func getFirstPositive(_ v1: Int, _ v2: Int) -> Int {
return v1 > 0 ? v1 : v2
}
getFirstPositive(10, 20) // 10
getFirstPositive(-2, 20) // 20
getFirstPositive(0, -4) // -4
// 改成函数(闭包表达式)类型的参数，可以让v2延迟加载
func getFirstPositive1(_ v1: Int, _ v2: () -> Int) -> Int? {
return v1 > 0 ? v1 : v2()
}
getFirstPositive1(-4) { 20 } //很丑
//改成自动闭包，注意这里使用了@autoclosure
func getFirstPositive2(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int? {
return v1 > 0 ? v1 : v2()
}
getFirstPositive2(-4, 20) //自动将 20 封装成闭包 { 20 }
由于我们把第二个参数改成了函数(闭包表达式)，当传入-4，20的时候就是：getFirstPositive(-4) { 20 }，这样写比较丑，所以Swift提供了一种自动闭包的语法糖，autoclosure 会自动将 20 封装成闭包 { 20 }。
- @autoclosure 会自动将 () 封装成闭包 { T }
- 使用了@autoclosure的地方最好明确注释清楚这个值会被推迟执行
- @autoclosure 只支持 () -> T 格式的参数
- 有@autoclosure、无@autoclosure，构成了函数重载
- 空合并运算符 ?? 使用了 @autoclosure 技术，源代码如下：
public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?)
rethrows -> T? {
switch optional {
case .some(let value):
return value
case .none:
return try defaultValue()
}
}
