Swift 闭包

前言

本篇文章主要讲解Swift中又一个相当重要的知识点 👉 闭包，首先会介绍闭包的概念，包含与OC中Block的区别点，接着会从底层分析闭包的原理，最后会讲解一些特殊的闭包的使用场景。

一、概念及使用

什么是闭包? 👉 一个捕获了全局上下文的常量或者变量的函数。闭包在实现上是一个结构体，它存储了一个函数（通常是其入口地址）和一个关联的环境（相当于一个符号查找表）。

1.1 全局函数

全局函数一种特殊的闭包，例如👇

func test(){
    print("test")
}

上面的test是一个无捕获变量的全局函数，也属于闭包。

1.2 内嵌函数

与全局函数一样，也是闭包，区别在于会捕获外部变量。例如👇

func makeIncrementer() -> () -> Int{
    var runningTotal = 10
    //内嵌函数，也是一个闭包
    func incrementer() -> Int{
        runningTotal += 1
        return runningTotal
    }
    return incrementer
}
print(makeIncrementer())  
print(makeIncrementer()())

上例中的incrementer是内嵌函数，也是一个闭包，捕获了上层函数的变量runningTotal。运行结果👇

1.3 闭包表达式

闭包表达式格式如下👇

{ (参数)-> 返回类型 in
    // do something
}

具有以下几个特点：

是一个匿名函数
所有代码都在花括号{}内
参数和返回类型在in关键字之前
in关键字之后是主体内容(类似方法体)

看上去是否和OC中的Block相似？OC中的Block的特点是👇

也是个匿名函数
主体内容和作用域都在花括号{}内部
也具有参数和返回值

Swift的闭包可以当作let常量、var变量，也可以当作参数传递👇

// 常量
let closure1: (Int) -> Int

// 变量
var closure2 : (Int) -> Int = { (age: Int) in
     return age
}

// 参数传递
func test(params: ()->Int) {
    print(params())
}

Swift闭包支持可选类型 👉 在()外使用?声明 👇

//声明一个可选类型的闭包
// 错误写法
var clourse: (Int) -> Int?
clourse = nil

// 正确写法
var clourse1: ((Int) -> Int)?
clourse1 = nil

1.4尾随闭包

当闭包表达式作为函数的最后一个参数时，可通过尾随闭包的书写方式来提高代码的可读性👇

// test函数：其中最后一个入参by是一个闭包
func test(_ a: Int, _ b: Int, _ c: Int, by: (_ item1: Int, _ item: Int, _ item3: Int) -> Bool) -> Bool{
    return by(a, b, c)
}

// 常规写法
test(10, 20, 30, by: { (_ itme1: Int, _ itme2: Int, _ itme3: Int) -> Bool in
    return itme1 + itme2 < itme3
})

// 快捷写法(小括号提到最后一个参数前)
test(10, 20, 30) { (_ itme1: Int, _ itme2: Int, _ itme3: Int) -> Bool in
    return itme1 + itme2 < itme3
}

// 最简洁写法 (入参直接使用$0 $1 $2代替，单行代码可省略return)
test(10, 20, 30) { $0 + $1 < $2 }

上面示例代码，一步步地简写，到最后，最简洁的写法看上去非常舒服，语义表达也很清晰。我们平常使用的array.sorted其实就是一个尾随闭包，且这个函数就只有一个参数👇

// array.sorted就是一个【尾随闭包】
var array = [1, 2, 3]
// 完整写法
array.sorted{(item1: Int, item2: Int)->Bool in return item1 < item2}
// 省略参数类型 👉 可通过array中元素的类型推断
array.sorted{(item1, item2)->Bool in return item1 < item2}
// 省略参数类型 + 返回值类型 👉 可通过return表达式推断出返回值类型
array.sorted{(item1, item2) in return item1 < item2}
// 省略参数类型 + 返回值类型 + return关键字 👉 单表达式可以隐士表达，即省略return关键字
array.sorted{(item1, item2) in item1 < item2}
// 简写参数名称
array.sorted{return $0 < $1}
// 简写参数名称 + 省略return关键字
array.sorted{$0 < $1}
// 最简单化，注意 👉 使用的是【小括号()】
array.sorted(by: <)

小结

最后，我们来总结一下闭包表达式的优点👇

利用上下文推断参数和返回类型

单表达式可以隐式返回，省略return关键字

参数名称可以直接使用简写(如$0,$1,元组的$0.0)

尾随闭包可以更简洁的表达

二、闭包底层原理

我们主要探讨2个点：

如何捕获变量？
闭包的类型是值类型还是引用类型？

2.1 捕获变量

首先看看下面的示例输出什么？👇

func makeIncrementer() -> () -> Int{
    var runningTotal = 10
    //内嵌函数，也是一个闭包
    func incrementer() -> Int{
        runningTotal += 1
        return runningTotal
    }
    return incrementer
}
let makeInc = makeIncrementer()
print(makeInc())
print(makeInc())
print(makeInc())

结果是不是和你们想的不一样？因为runningTotal是局部变量，每次调用makeIncrementer方法累加1，结果应该都是11，但是事实却是11，12，13，为什么会这样？👇

主要原因：内嵌函数捕获了runningTotal，不再是单纯的一个变量了。

如果是这么调用👇

print(makeIncrementer()())
print(makeIncrementer()())
print(makeIncrementer()())

这次又都是11，和我们之前想的一样，很有意思。还是老办法，先从SIL中间层代码分析👇

swiftc -emit-sil xx.swift| xcrun swift-demangle >> ./xx.sil && vscode xx.sil

直接看函数makeIncrementer()代码👇

上图可见，内嵌函数incrementer()中的变量runningTotal是通过alloc_box在堆上开辟的内存空间，然后通过project_box读取runningTotal，交给闭包使用，所以👇

捕获值的本质是 👉 将变量存储到堆上。

不信，我们还可以打断点👇

看看汇编👇

这里也可以看出，在makeIncrementer()方法内部调用了初始化swift_allocObject，使用时swift_retain，调用结束后swift_release，所以我们上面的判断是正确的。

小结

一个闭包能够从上下文捕获已经定义的常量和变量，并且能够在其函数体内引用和修改这些值，即使这些定义的常量和变量的原作用域不存在
修改捕获值实际是修改堆区中的value值
当每次重新执行当前函数时，都会重新创建内存空间

所以上面示例中结果就是👇

makeInc是用于存储makeIncrementer函数调用的全局变量，所以每次都需要依赖上一次的结果
而直接调用函数makeIncrementer()()时，相当于每次都新建一个堆内存，所以每次的结果都存储在不同的内存空间，互不影响，于是每次结果都是一样的11。

2.2 闭包的类型

闭包究竟是值类型呢？还是引用类型？先把答案公布出来 👉 引用类型。也就是上面的实例代码中的变量makeInc，它里面存储的是什么？接下来我们来证明一下。

IR基础语法

老办法，我们去查看SIL中间层代码，但是发现，通过SIL并没有办法分析出什么，此时怎么办呢？ 👉 通过IR代码来观察数据的构成。所以，我们先来看看IR基础语法 👉 官方文档

首先，生成IR的命令行👇

swiftc -emit-ir xx.swift > ./xx.ll && vscode xx.ll

数组👇

/*
- elementnumber 数组中存放数据的数量
- elementtype 数组中存放数据的类型
*/
[<elementnumber> x <elementtype>]

// 举例
/*
24个i8都是0
- iN：表示多少位的整型，即8位的整型 - 1字节
*/
alloca [24 x i8], align 8

结构体👇

/*
- T：结构体名称
- <type list> ：列表，即结构体的成员列表
*/
//和C语言的结构体类似
%T = type {<type list>}


// 举例
/*
- swift.refcounted：结构体名称
- %swift.type*：swift.type指针类型
- i64：64位整型 - 8字节
*/
%swift.refcounted = type { %swift.type*, i64}

指针类型

<type> *

// 举例
// 64位的整型 - 8字节
i64*

getelementptr指令
在LLVM中获取数组和结构体的成员时通过getelementptr，语法规则👇

<result> = getelementptr <ty>, <ty>* <ptrval>{, [inrange] <ty> <id x>}*
<result> = getelementptr inbounds <ty>, <ty>* <ptrval>{, [inrange] <ty> <idx>}*

示例1

// 举例
struct munger_struct{
    int f1;
    int f2;
};
void munge(struct munger_struct *P){
    P[0].f1 = P[1].f1 + P[2].f2;
}

// 使用
struct munger_struct* array[3];

int test() {
    
    munge(array);
    
    return 0;
}

通过下面的命令将c/c++编译成IR👇

clang -S -emit-llvm 文件名xx > ./.ll && vscode main.ll

// 举例
clang -S -emit-llvm ${SRCROOT}/SwiftTest/main.c > ./main.ll && vscode main.ll

上图中倒数第三行 👉 第一个索引 %struct.munger_struct* %13, i32 0 -> 第一个索引类型 + 第一个索引值 -> 第一个索引的偏移量
第二个索引：i32 0

示例2

int test1() {
    int array[4] = {1, 2, 3, 4};
    int a = array[0];
    return 0;
}

所对应的IR代码👇

示例3

现在基本上熟悉了IR语法规则了，接下来我们看之前的例子👇

func makeIncrementer() -> (()-> Int){
    var runningTotal = 10
    func incrementer() -> Int {
        runningTotal += 1
        return runningTotal
    }
    return incrementer
}
// 函数变量 （存储格式是怎样？）
var makeInc = makeIncrementer()

其IR代码👇

结构体声明

先看第3行：声明一个名称为type的结构体，只有一个成员且是int64类型
第2行：refcounted结构体 👉 2个成员 type + int64
第1行：function结构体 👉 2个成员指针i8* + refcounted
第4行：full_boxmetadata 👉 5个成员 refcounted结构体指针 + 指针i8**(二级指针) + type + int32 + 指针i8*
最后一行：TSi结构体模板类，只有一个成员int64类型

main函数

makeIncrementer函数

上图中我们发现，外层函数makeIncrementer是一个结构体对象，而内嵌函数incrementer被转换成void *指针，作为外层结构体对象的一个成员变量，所以，闭包是引用类型。

2.3 伪代码实现

上面示例3内嵌函数的示例，我们通过对IR代码的分析，得知了闭包是引用类型，也清楚了整体的一个实现流程，现在我们用伪代码实现一下该流程（和示例3一样分为3部分）👇

部分1：结构体的定义

type结构体

struct Type {
    var type: Int64
}

refcounted结构体

struct Refcounted {
    var pointer: UnsafeRawPointer
    var refCount: Int64
}

function结构体

struct FunctionData<T> {
    var pointer: UnsafeRawPointer
    var captureValue: UnsafePointer<T>
}

full_boxmetadata

struct BoxMetadata<T> {
    var refcounted: UnsafePointer<Refcounted>
    var undefA: UnsafeRawPointer
    var type: Type
    var undefB: Int32
    var undefC: UnsafeRawPointer
}

makeIncrementer函数值有将 refcounted结构体做了强制转换，如下图中绿框中的结构体👇

struct Box<T> {
    var refcounted: Refcounted
    var value: T  // 8字节类型，可由外部动态传入
}

上述IR代码分析得知，makeIncrementer函数最后转换成了一个结构体，原因 👉 因为无法直接读取makeIncrementer返回的是()-> Int，而()-> Int的地址，可以利用结构体地址就是首元素地址的特性，将()-> Int设为结构体第一个属性👇

struct VoidIntFunc {
    var f: ()->Int
}

所有结构体已定义完毕，接下来在用伪代码实现一下makeIncrementer函数👇

func makeIncrementer() -> (()-> Int){
    var runningTotal = 10
    
    func incrementer() -> Int {
        runningTotal += 1
        return runningTotal
    }
    
    return incrementer
}

伪代码实现👇

// 使用struct包装的函数
var makeInc = VoidIntFunc(f: makeIncrementer())
// 取地址
let ptr = UnsafeMutablePointer<VoidIntFunc>.allocate(capacity: 1)
// 初始化
ptr.initialize(to: makeInc)
// 将指针绑定为FunctionData<Box<Int>>类型,返回指针
let context = ptr.withMemoryRebound(to: FunctionData<Box<Int>>.self, capacity: 1) { $0.pointee }

打印看看

print(context.pointer)
print(context.captureValue.pointee.value)

Mach-O验证

打开可执行二进制文件👇
打开终端，输入👇

nm -p 编译后的machO文件地址 | grep 函数地址

// 例如：
nm -p /Users/asetku/Library/Developer/Xcode/DerivedData/Demo-bhpsxmnrzusvmeaotyclgmelcxpp/Build/Products/Debug/Demo | grep 00000001000054b0

所以当我们var makeInc2 = makeIncrementer()使用时，相当于makeInc2也关联了FunctionData结构体，那么makeIncrementer()的内嵌函数地址，以及捕获变量的地址也是同一个，所以才能在上一个的基础上进行累加。

2.4 拓展：函数内部多个属性

如果函数内部多个属性，在底层对应的结构体是怎样的呢？示例代码👇

func makeIncrementer() -> (()-> Int){
   var aa = 10
   var bb = 20
   // 内嵌函数（也是一个闭包，捕获了runningTotal）
   func incrementer() -> Int {
       aa += 6
       bb += 9
       return bb
   }
   return incrementer
}
var makeInc = makeIncrementer()

查看IR代码👇

基础结构体声明👇 没有变化

makeIncrementer函数 👉 与一个属性的相比，多了一个临时结构，把两个变量分别用指针记录👇

伪代码

添加一个Box2<T>结构体👇

struct Box<T> {
   var refcounted: Refcounted
   var value: T  // 8字节类型，可由外部动态传入
}

// 多了一个Box2结构，每个变量都是`Box`结构的对象
struct Box2<T> {
   var refcounted: RefCounted
   var value1: UnsafePointer<Box<T>>
   var value2: UnsafePointer<Box<T>>
}

调用的代码是这样👇

func makeIncrementer() -> (()-> Int){
  var aa = 10
  var bb = 20

  func incrementer() -> Int {
      aa += 6
      bb += 9
      return bb
  }
  return incrementer
}

var makeInc = VoidFunc(f: makeIncrementer())

let ptr = UnsafeMutablePointer<VoidFunc>.allocate(capacity: 1)

ptr.initialize(to: makeInc)

let context = ptr.withMemoryRebound(to: FunctionData<Box2<Int>>.self, capacity: 1) { $0.pointee }

print(context.pointer)
print(context.captureValue.pointee.value1.pointee.value)
print(context.captureValue.pointee.value2.pointee.value)

运行👇

接着在Mach-O中校验地址👇

完美！

2.5 小结

捕获值原理：在堆上开辟内存空间，并将捕获的值放到这个内存空间里
修改捕获值时：实质是修改堆空间的值
闭包是一个引用类型（引用类型是地址传递），闭包的底层结构 👉 结构体：(函数地址 + 捕获变量的地址 == 闭包）
函数也是一个引用类型（本质是一个结构体，其中只保存了函数的地址）

三、特殊的闭包

最后，完美来看看一些常用的，特殊的闭包类型：逃逸闭包、非逃逸闭包和自动闭包。

3.1 (非)逃逸闭包的概念

逃逸闭包：
当闭包作为函数的参数，且在函数返回之后调用，我们就说这个闭包逃逸了。
(逃逸闭包作为函数形参时，需要使用@escaping声明，生命周期比函数要长。如：被外部变量持有或异步延时调用)
非逃逸闭包：
系统默认闭包参数是@nonescaping声明, 是非逃逸闭包，生命周期与被调用的函数保持一致。

3.1.1 逃逸闭包

大致有2种场景👇

闭包被函数外变量持有，需要@escaping声明为逃逸闭包

// 闭包作为属性
class LGTeacher {
    // 定义一个闭包属性
    var complitionHandler: ((Int)->Void)?
    // 函数参数使用@escaping修饰，表示允许函数返回之后调用
    func makeIncrementer(amount: Int, handler: @escaping (Int)->Void){
        var runningTotal = 0
        runningTotal += amount
        // 赋值给属性
        self.complitionHandler = handler
    }

    func doSomething(){
        self.makeIncrementer(amount: 10) {
            print($0)
        }
    }

    deinit {
        print("LGTeacher deinit")
    }
}
// 调用代码👇
var t = LGTeacher()
t.doSomething()
t.complitionHandler?(10)

闭包被异步线程延时调用，需要@escaping声明为逃逸闭包

class LGTeacher {
    // 定义一个闭包属性
    var complitionHandler: ((Int)->Void)?
    // 函数参数使用@escaping修饰，表示允许函数返回之后调用
    func makeIncrementer(amount: Int, handler: @escaping (Int)->Void){
        var runningTotal = 0
        runningTotal += amount
        // 赋值给属性
        self.complitionHandler = handler
        
        // 延迟调用
        DispatchQueue.global().asyncAfter(deadline: .now()+2) {
            print("逃逸闭包延迟执行")
            handler(runningTotal)
        }
        print("函数执行完了")
    }

    func doSomething(){
        self.makeIncrementer(amount: 10,handler: {
            print($0)
        })
    }

    deinit {
        print("LGTeacher deinit")
    }
}
// 调用代码👇
var t = LGTeacher()
t.doSomething()

3.1.2 非逃逸闭包

系统默认闭包为非逃逸闭包 ,编译期自动加上@noescape声明，生命周期与函数一致。

func test(closure: (()->())) {}

SIL编译可以看到默认使用@noescape声明闭包👇

逃逸闭包 vs 非逃逸闭包区别

非逃逸闭包 👉 一个接受闭包作为参数的函数，闭包是在这个函数结束前内被调用，即可以理解为闭包是在函数作用域结束前被调用
1. 不会产生循环引用，因为闭包的作用域在函数作用域内，在函数执行完成后，就会释放闭包捕获的所有对象
2. 针对非逃逸闭包，编译器会做优化 👉 省略内存管理调用
3. 非逃逸闭包捕获的上下文保存在栈上，而不是堆上（官方文档说明）。
逃逸闭包：一个接受闭包作为参数的函数，逃逸闭包可能会在函数返回之后才被调用，即闭包逃离了函数的作用域
1. 可能会产生循环引用，因为逃逸闭包中需要显式的引用self（猜测其原因是为了提醒开发者，这里可能会出现循环引用了），而self可能是持有闭包变量的（与OC中block的的循环引用类似）
2. 一般用于异步函数的返回，例如网络请求
使用建议：如果没有特别需要，开发中使用非逃逸闭包是有利于内存优化的，所以苹果把闭包区分为两种，特殊情况时再使用逃逸闭包

3.2 自动闭包

自动识别闭包返回值，可直接接收返回值类型数据。
需要用@autoclosure声明，不接收任何参数，返回值是当前内部表达式的值（如()->String)

// 自动闭包`@autoclosure`声明
func testPrint(_ message: @autoclosure ()->String) {
    print(message())
}

func doSomeThing() -> String {
    return "吃了吗？"
}
// 入参传`函数`
testPrint(doSomeThing()) 
// 入参传`字符串`
testPrint("干啥呢")

可以看到，使用自动闭包时，参数可以是函数，也可以是闭包返回类型（字符串）。
自动闭包可以兼容函数入参类型（函数/函数返参类型）

耗时场景

再看下面这个例子👇

func testPrint(_ condition: Bool, _ message: String) {
    if condition {
        print("错误信息: \(message)")
    }
    print("结束")
}

func doSomeThing() -> String {
    print("执行了")
    // 耗时操作，从0到1000拼接成字符串
    return (0...1000).reduce("") { $0 + " \($1)"}
}

testPrint(false, doSomeThing())

doSomeThing函数里吗执行了一个for循环，是一个耗时操作，然后将计算结果传给testPrint时，但是testPrint的condition是false，条件不满足时，根本不需要关心message，即不需要执行这个耗时的操作，所以这里相当于做了多余的事。那能否避开这样的场景呢？

修改入参
将message参数修改成一个闭包，需要传入的是一个函数👇

func testPrint(_ condition: Bool, _ message: () -> String) {
    if condition {
        print("错误信息: \(message())")
    }
    print("结束")
}

func doSomeThing() -> String {
    print("执行了")
    // 耗时操作，从0到1000拼接成字符串
    return (0...1000).reduce("") { $0 + " \($1)"}
}

testPrint(false, doSomeThing)

此时避免了不必要的耗时操作，但是，message入参只接收闭包类型，那能否做到message也能接收字符串类型呢？👉 是可以的，可以通过@autoclosure将当前的闭包声明成一个自动闭包，那么message此时不接收任何参数，返回值是当前内部表达式的值👇

此时的message入参的闭包就相当于👇

{
    //表达式里的值
    return "something error"
}

总结

本篇文章围绕闭包这个知识点，首先介绍了闭包的概念和使用场景，接着从底层探究了闭包捕获变量的原理和闭包的类型，最后重点介绍了闭包三种常用的特殊场景：逃逸闭包、非逃逸闭包和自动闭包，对于底层原理的分析，希望大家能掌握这种探究问题的思路。