Swift 闭包

2021-02-05 本文已影响0人深圳_你要的昵称

前言

本篇文章主要讲解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"
}

总结

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

Swift 闭包

前言

一、概念及使用

1.1 全局函数

1.2 内嵌函数

1.3 闭包表达式

1.4尾随闭包

小结

二、闭包底层原理

2.1 捕获变量

小结

2.2 闭包的类型

IR基础语法

示例1

示例2

示例3

2.3 伪代码实现

部分1：结构体的定义

Mach-O验证

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

伪代码

2.5 小结

三、特殊的闭包

3.1 (非)逃逸闭包的概念

3.1.1 逃逸闭包

3.1.2 非逃逸闭包

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

3.2 自动闭包

耗时场景

总结

猜你喜欢

热点阅读

Swift 闭包

前言

一、概念及使用

1.1 全局函数

1.2 内嵌函数

1.3 闭包表达式

1.4尾随闭包

小结

二、闭包底层原理

2.1 捕获变量

小结

2.2 闭包的类型

IR基础语法

示例1

示例2

示例3

2.3 伪代码实现

部分1：结构体的定义

Mach-O验证

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

伪代码

2.5 小结

三、特殊的闭包

3.1 (非)逃逸闭包的概念

3.1.1 逃逸闭包

3.1.2 非逃逸闭包

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

3.2 自动闭包

耗时场景

总结

猜你喜欢

热点阅读

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