美文网首页Swift学习内存Swift
Swift 闭包

Swift 闭包

作者: 深圳_你要的昵称 | 来源:发表于2021-02-05 09:37 被阅读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
}

    具有以下几个特点：

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

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

    1. 也是个匿名函数
    2. 主体内容和作用域都在花括号{}内部
    3. 也具有参数和返回值
    • 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个点：

    1. 如何捕获变量？
    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，所以我们上面的判断是正确的。

    小结

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

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

    1. makeInc是用于存储makeIncrementer函数调用的全局变量，所以每次都需要依赖上一次的结果
    2. 而直接调用函数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代码👇

    • 结构体声明
    1. 先看第3行：声明一个名称为type的结构体，只有一个成员且是int64类型
    2. 第2行：refcounted结构体 👉 2个成员 type + int64
    3. 第1行：function结构体 👉 2个成员 指针i8* + refcounted
    4. 第4行：full_boxmetadata 👉 5个成员 refcounted结构体指针 + 指针i8**(二级指针) + type + int32 + 指针i8*
    5. 最后一行：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验证

    1. 打开可执行二进制文件👇


    2. 打开终端，输入👇

    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函数 👉 与一个属性的相比，多了一个临时结构，把两个变量分别用指针记录👇
    伪代码
    1. 添加一个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>>
}
    1. 调用的代码是这样👇
    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 小结

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

    三、特殊的闭包

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

    3.1 (非)逃逸闭包的概念

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

    3.1.1 逃逸闭包

    大致有2种场景👇

    1. 闭包被函数外变量持有，需要@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)
    1. 闭包被异步线程延时调用，需要@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 闭包

        本文链接：https://www.haomeiwen.com/subject/aznjtltx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        Swift学习

        内存

        Swift

        关于我们|服务条款|联系我们|Swift 闭包|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！