目录

• 版本
• 闭包的定义及使用
• 尾随闭包
• 逃逸闭包

版本

Xcode 11.0
Swift 5.1

闭包的定义及使用

1. 概念
闭包是自包含的函数代码块，可以在代码中被传递和使用。Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的匿名函数（Lambdas）比较相似。
其实全局函数和嵌套函数实际上也是特殊的闭包，区别如下：

• 全局函数是一个有名字但不会捕获任何值的闭包
• 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
• 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包

关于捕获值后文有介绍

2. 定义 (表达式)
在讨论闭包的定义之前, 我们先来回顾一下全局函数和嵌套函数.

// 函数表达式
func 函数名(参数列表) -> 返回类型 {
    // 函数体
}

如上表达式, 定义在全局域中则称为全局函数, 定义在某个函数体中则称为嵌套函数.
下面来看看闭包的表达式是如何定义的:

// 闭包表达式
{ (参数列表) -> 返回值类型 in
    // 闭包体 (可执行代码语句)
}

对比函数和闭包的表达式, 有以下不同点:

• 函数有名称; 闭包没有名称.
• 函数大括号在返回类型后面, 包裹了函数体; 闭包大括号则包裹了所有 参数 / 返回值 / in关键字 / 闭包体.
• 闭包的闭包体处在 in 关键字后面区域
• 闭包表达式参数可以是 in-out 参数，但不能设定默认值。

3. 使用 (实例)
闭包实例:

// 定义一个闭包, 并赋值给一个常量 maxValue
// 或者说定义一个常量 maxValue 指向后面这个闭包
let maxValue: (Int, Int) -> Int = { (x: Int, y: Int) -> Int in
    return x > y ? x : y
}

// 使用 maxValue 来调用闭包
print(maxValue(11, 22))
// 打印 22

4. 上下文推断 和 隐式返回
由于Swift可以推断参数和返回值类型, 并且单行表达式闭包可以通过省略 return 关键字来隐式返回单行表达式的结果, 所以上面的代码又可以简写为:

// 定义
let maxValue: (Int, Int) -> Int = { x, y in x > y ? x : y }

// 使用 maxValue 来调用闭包
print(maxValue(11, 22))
// 打印 22

5. 参数名称缩写
Swift 自动为内联闭包提供了参数名称缩写功能，你可以直接通过 $0，$1，$2 来顺序调用闭包的参数，以此类推。

// 参数名称缩写
// 定义一个闭包, 并赋值给一个常量 add
let add: (Int, Int) -> Int = { $0 + $1 }

// 使用 add 来调用闭包
print(add(11, 22))
// 打印 33

6. 捕获值
类似于嵌套函数, 闭包也可以捕获外部的值.
闭包可以在其被定义的上下文中捕获常量或变量。即使定义这些常量和变量的原作用域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。

// 捕获值
var aa = 10
let setValue: () -> () = {
    aa = 88
}

// 调用闭包 (无参数无返回值)
setValue()
print(aa)
// 打印 88

闭包作为函数参数

定义一个加法函数, 传入三个参数: aClosure: (Int, Int) -> Int 和 x: Int 和 y: Int, 返回值是 Int 类型. 闭包也是传入两个参数 Int 返回一个 Int 值, 在函数体内返回闭包的返回值.
代码如下:

// 定义函数
func doAdd(aClosure: (Int, Int) -> Int, x: Int, y: Int) -> Int {
    return aClosure(x, y)   // 传入函数的x/y值, 返回闭包的返回值
}

// 调用函数, 在这里写闭包体
let ret = doAdd(aClosure: { (aa, bb) -> Int in
    return aa + bb          // 闭包体部分: 接收函数的x/y值进行相加
}, x: 10, y: 15)

print(ret)
// 打印 25

尾随闭包

上面的例子中, 在函数中传入闭包当做参数, 这种写法可读性不强. 下面我们来介绍尾随闭包.
顾名思义, 尾随闭包就是放在最后面的闭包。进一步说, 尾随闭包是一个书写在函数圆括号之后的闭包表达式，函数支持将其作为最后一个参数调用。
上面的相加函数使用尾随闭包, 加强可读性:

// 定义函数 (三个形参:x,y和闭包aClosure; 一个返回值Int类型)
func doAdd(x: Int, y: Int, aClosure: (Int, Int) -> Int) -> Int {
    return aClosure(x, y)
}

// 调用函数, 此时闭包体已经移到()外边
let ret = doAdd(x: 10, y: 20) { (aa, bb) -> Int in
    return aa + bb
}

print(ret)
// 打印 30

注意
必须将闭包作为函数的最后一个参数才能成为尾随闭包.

逃逸闭包

假如我们将一个闭包传入函数作为参数, 然后异步调用这个闭包:

import Foundation

// 定义函数
func doNothing(aClosure: () -> ()) {
    
    DispatchQueue.global().async {
        aClosure()      // 异步调用闭包
    }
}

// 调用函数
doNothing {
    print("调用了闭包")
}

// 编译报错

此时编译的时候会报错. 因为异步调用闭包的代码在doNothing函数返回之后才执行, 而闭包作为一个局部变量在函数返回之后就被释放了, 此时调用就会报错. 逃逸闭包能解决这个问题.

当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注 @escaping，用来指明这个闭包是允许“逃逸”出这个函数的。

再看刚才的例子, 成功运行:

import Foundation

// 定义函数
func doNothing(aClosure: @escaping () -> ()) {
    
    DispatchQueue.global().async {
        aClosure()      // 异步调用闭包
    }
}

// 调用函数
doNothing {
    print("调用了闭包")
}

// 打印 调用了闭包

注意
将一个闭包标记为 @escaping 意味着你必须在闭包中显式地引用 self。