一. 闭包表达式（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))
}
// 写成尾随闭包，增强函数的可读性
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}
nums.sort {$0 < $1} //[2, 5, 6, 11, 18, 45, 68]
四. 闭包（Closure）
1. 什么是闭包
网上有各种关于闭包的定义，个人觉得比较严谨的定义是：
一个函数和它所捕获的变量 \ 常量环境组合起来，称为闭包
一般指定义在函数内部的函数
一般它捕获的是外层函数的局部变量 \ 常量
闭包如下：
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 占用 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)) // 22
print(fn1(3)) // 28
var fn2 = getFn()
print(fn2(2)) // 24
print(fn2(4)) // 32
}
testClosure()
由于我不会看汇编，猜测一下：由于 Person 对象本来就在堆空间，所以如果 plus 函数捕获了 Person 对象，应该是将 Person 对象的指针保存到闭包里面了，plus 函数内部会根据 Person 对象的修饰符 (__strong、__weak、__unsafe_unretained) 做出相应的操作，形成强引用 (retain) 或者弱引用，这样以后如果要使用 Person 对象，就直接通过闭包里面 Person 对象的指针访问就可以了。
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)
如上，add 函数返回的函数类型要和 plus 函数的类型保持一致。
五. 自动闭包
为什么使用延迟加载？如下代码：
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
上面既然第一个参数传入了 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
这样就实现了，需要调用第二个函数的时候才调用第二个函数，不需要的时候就不调用。(比如一些网络请求啊，如果前面的符合条件就没必要进行请求了)
再看下面代码：
// 如果第 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} // 很丑
// 改成自动闭包
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 技术，源代码如下：
public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?)
rethrows -> T? {
switch optional {case .some(let value):
return value
case .none:
return try defaultValue()}
}推荐
面试题持续更新记得关注我哦！
不同的圈子就有不同的学习方式；
（qq 群搜索）：651612063 群密码：111 进群文件可以直接获取大厂面试题