剑客
关注科技互联网

Optional 与 Non-Escaping 的闭包

原文: Optional Non-Escaping Closures

作者: Ole Begemann

译者:kemchenj

Swift 里如何区分 escaping (逃逸)和 non-escaping (非逃逸)的闭包呢? escaping closure(逃逸闭包)
作为函数参数在函数 return 之后(可能会)被调用. 也就是说这个 escaping 闭包被传递到了外部, 逃出当前的函数的作用域.

逃逸闭包经常会跟异步操作联系在一起, 就像下面的例子:

  • 一个函数发起一个后台任务然后立刻返回, 通过一个 completion handler 回调去汇报结果
  • 一个 View 的类保存了一个闭包去处理按钮点击事件, 每次用户点击这个按钮的时候就会去调用这个闭包, 这个闭包就会逃出这个属性的生命周期
  • 你用 DispatchQueue.async
    在一个线程里发起异步任务, 这个任务闭包就比发起异步任务的函数存活得更久.

与之相对的, DispatchQueue.sync
会等到任务闭包执行完成, 然后再 return – 这个闭包就永远不会逃逸了. 类似的还有 map
和其它标准库里常用的序列和集合的算法.

为什么区分开 escaping 和 non-escaping 的闭包那么重要?

四个字概括, 内存管理. 一个闭包会持有闭包内捕获的变量的强引用, 如果你访问了成员变量和调用了函数的话, 还会对 self
产生强引用, 因为这会隐式地把 self
作为参数传入.

一不小心就会非常容易引入 reference cycles(循环引用)
, 这就是编译器要求你显式地在闭包内写出 self
的原因. 这会强制你去思考潜在的循环引用风险并且手动通过 capture lists(捕获列表)
去解决它.

但无论如何, 都不可能会在一个 non-escaping 的闭包里发生循环引用 – 编译器会保证在函数 return 的时候, 闭包会 release 所有捕获的变量. 所以, 编译器只要求在 escaping 的闭包里显式地把 self
写出来. 这会让 non-escaping 的闭包更容易使用.

non-escaping 闭包的另一个好处就是编译器可以采取更激进的性能优化. 例如, 编译器因为知道了闭包的生命周期, 所以可以删掉一些不必要的 retain
release
. 另外, 非逃逸的闭包的上下文也可以保存在栈而不是堆里, 虽然我不知道现在 Swift 的编译器对这个优化得怎么样 ( open March 2016 bug report
这个提案好像说到了 Swift 还没做这个优化)

闭包默认为 non-escaping …

从 Swift 3开始, non-escaping 闭包 闭包默认声明为 non-escaping
, 如果你想让参数闭包逃逸的话, 你需要加上一个 @escaping
去修饰类型. 举个现实的例子, 下面是 DispatchQueue.async
(escaping) 和 DispatchQueue.sync
(non-escaping) 的声明:

classDispatchQueue{
 ...
funcasync(/* other params omitted */, execute work: @escaping()->Void)
funcsync<T>(execute work:()throws->T)rethrows->T
}

Swift 3 之前, 是另一种做法: 默认为 escaping, 并且你需要加上 @non-escaping
修饰. 新的做法更好, 因为默认情况下是安全的(不会发生循环引用): 一个函数参数如果有潜在的循环引用的风险, 就必须显式地书写出来. 这样子, @escaping
修饰符就可以作为开发者使用函数时的一个安全提示存在.

… 但只适用于”即时函数参数”(immediate function parameters)

There’s a catch to the non-escaping-by-default rule: it only applies to closures in immediate function parameter position, i.e. any function argument that has a function type. All other closures are escaping.

默认 non-escaping 有一个很重要的规则: 它只适用于作为参数传入函数的闭包, 例如: 任何作为参数传入的闭包. 其它所有闭包都是 escaping 的.

作为”即时函数参数”是什么意思?

Let’s look at some examples. The simplest case is something like map: a function that takes an immediate closure parameter. As we’ve seen, the closure is non-escaping (I omitted some details from the real signature of map that are not important for this discussion):

让我们来看一些例子. 最简单的例子就是像 map
这样的高阶函数: 一个接收闭包参数的函数. 就像我们看的的这样, 这是一个 non-escaping 的闭包(这里删掉了一些跟讨论无关的 map
的细节):

funcmap<T>(_transform:(Iterator.Element)->T) -> [T]

函数参数总是逃逸的

与此不同的是闭包类型的变量或者属性, 它们都默认为 escaping, 甚至不用显示地声明(实际上, 显式地加上 escaping
还会报错). 这其实很合理, 因为把一个值赋值给变量很明显就会让这个值逃逸到变量的作用域, non-escaping 的闭包明显就不能这么做. 说起来可能会让你觉得有点晕, 但显而易见的是, 参数列表里的闭包跟任何别的情况都不一样.

Optional 的闭包必须为 escaping

更让人意外的是, 参数作为闭包, 但是被封装到别的类型里(例如元组, 枚举或者是可选类型), 就都是 escaping 的. 因为这里的函数都不是作为即时参数传入, 它会自动转变为 escaping. 这造成的结果就是, Swift 3.0 里你没办法在函数的参数里声明一个既是 Optional 又是 non-escaping 的闭包. 思考下面的例子, transform
函数接收一个 Int
类型的参数 n 和一个 Optional 类型的闭包 f. 它会返回 f(n)
, 而 f 为 nil
的时候返回 n
:

/// Applies `f` to `n` and returns the result.
/// Returns `n` unchanged if `f` is nil.
functransform(_n: Int, with f:((Int)->Int)?) ->Int{
guardletf = felse{returnn }
returnf(n)
}

这里, 闭包 f 是 escaping 的, 因为 ((Int) -> Int)?
其实是 Optional<(Int) -> Int>
的简写, 而不是作为即时参数存在. 这不是我们想要的, 因为这里 f 不可能逃逸.

用默认值去取代 optional

Swift 团队 注意到了这个做法的局限性
并且计划在以后的版本里修复它. 现在必须留意到这一点, 但现在还是没有办法把一个 escaping 的闭包强制转换为 non-escaping, 不过在很多情况下, 你可以通过给闭包参数一个默认值去避免让参数声明为 Optional
. 在下面的例子里, 默认值是直接把原参数传回的闭包:

/// 当 f 没有传入的时候, 直接给 f 提供一个默认的实现
functransform(_n: Int, with f:(Int)->Int= { $0}) ->Int{
returnf(n)
}

使用重载提供 Optional 和 non-escaping 两个版本

如果不能够提供默认值的话, Michael Ilseman 建议 使用重载作为一种变通方法
, 你可以写给函数写两个版本, 一个用 Optional 作为参数, 另一个使用 non-optional, non-escaping:

// 重载 1: optional, escaping
functransform(_n: Int, with f:((Int)->Int)?) ->Int{
print("Using optional overload")
guardletf = felse{returnn }
returnf(n)
}

// 重载 2: non-optional, non-escaping
functransform(_input: Int, with f:(Int)->Int) ->Int{
print("Using non-optional overload")
returnf(input)
}

我加上了一些说明去示范一下这些函数怎么被调用. 让我们用不同的参数来测试一下, 不出意外, 如果你传 nil, 那么类型检查的时候就会选择 重载 1
:

transform(10, with:nil)// → 10
// 使用了 Optional 版本的重载

如果你传入一个 Optional 的闭包也会是同样的重载:

letf: ((Int) ->Int)? = { $0*2}
transform(10, with: f)// → 20
// 使用了 Optional 版本的重载

甚至变量的类型是 non-optional的, Swift 也会选择第一个重载. 这是因为闭包被保存在变量里的时候会自动逃逸, 所以这里不适用于第二个重载, 虽然我们希望重载的是第二个:

letg: (Int) ->Int= { $0*2}
transform(10, with: g)// → 20
// 使用了 Optional 版本的重载

但是如果你是直接把闭包传入就会变得不一样了, 现在会重载到 non-escaping 的版本:

transform(10) { $0*2}// → 20
// 使用了 non-optional 版本的重载

现在调用高阶函数传入闭包已经变得习以为常, 在大多数情况下, 使用这种方法可以让你用一种更加愉悦的方式去传入 nil. 如果你打算这么做的话, 请确保你在文档里列清楚为什么你需要两种重载.

Typealias 必须 escaping

最后一件你要注意的是, 在 Swift 3里你给闭包起别名的时候不能声明 escaping 或者 non-escaping. 如果你使用闭包别名作为函数参数类型的话, 需要注意这个闭包是且只能是 escaping 的. 一个 Fix for this bug
已经提上了日程并且应该会在下个版本里完成.

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址