defer 是干什么的
一句话概括就是 defer block 里的代码会在函数 return 之前执行，无论函数是从哪个分支 return 的，还是有 throw的，还是自然而然走到最后一行的。
这个关键字就跟 Java 里的 try-catch-finally 的finally一样，不管 try catch 走哪个分支，它都会在函数 return 之前执行。而且它比 Java 的finally还更强大的一点是，它可以独立于 try catch 存在，
所以它可以成为整理函数流程的帮手。
在函数 return 之前无论如何都要做的处理，
可以放进这个 block 里，让代码看起来更干净舒服。
swift 文档上的例子：
var fridgeIsOpen = false
let fridgeContent = ["milk", "eggs", "leftovers"]
func fridgeContains(_ food: String) -> Bool {
fridgeIsOpen = true
defer {
fridgeIsOpen = false
}
let result = fridgeContent.contains(food)
return result
}
fridgeContains("banana")
print(fridgeIsOpen)
例子里执行的顺序是：
先fridgeIsOpen = true，
然后是函数体正常的流程，
最后在 return 之前执行 fridgeIsOpen = false。
简单的几个使用场景
try catch 结构
最典型的场景，我想也是 defer 这个关键字诞生的主要原因吧：
func foo() {
defer {
print("finally")
}
do {
throw NSError()
print("impossible")
} catch {
print("handle error")
}
}
不管 do block 是否 throw error，有没有 catch 到，还是 throw 出去了，都会保证在整个函数 return 前执行 defer。
在这个例子里就是：
先 print 出 "handle error"
再 print 出 "finally"。
do block 里也可以写 defer：
do {
defer {
print("finally")
}
throw NSError()
print("impossible")
} catch {
print("handle error")
}
那么它执行的顺序就会是在 catch block 之前，也就是先 print 出 "finally" 再 print 出 "handle error"。
清理工作、回收资源
跟 swift 文档举的例子类似，defer一个很适合的使用场景就是用来做清理工作。比如文件操作：
关闭文件
func foo() {
let fileDescriptor = open(url.path, O_EVTONLY)
defer {
close(fileDescriptor)
}
// use fileDescriptor...
}
可以避免 哪个分支忘了写，或者中间 throw 个 error，导致 fileDescriptor 没法正常关闭。
dealloc 手动分配的空间
func foo() {
let valuePointer = UnsafeMutablePointer.allocate(capacity: 1)
defer {
valuePointer.deallocate(capacity: 1)
}
// use pointer...
}
加/解锁：下面是 swift 里类似 Objective-C 的 synchronized block 的一种写法，可以使用任何一个 NSObject 作 lock
成对调用 可以用 defer 把它们放在一起。
func foo() {
objc_sync_enter(lock)
defer {
objc_sync_exit(lock)
}
// do something...
}
调 completion block
有时候一个函数分支比较多可能某个小分支 return 之前就忘了调 completion block，结果藏下 bug。
func foo(completion: () -> Void) {
defer {
self.isLoading = false
completion()
}
guard error == nil else { return }
// handle success
}
有时候 completion 要根据情况传不同的参数，这时 defer 就不好用了。如果 completion block 被存下来了，我们还是可以用它来确保执行后能释放：
func foo() {
defer {
self.completion = nil
}
if (succeed) {
self.completion(.success(result))
} else {
self.completion(.error(error))
}
}
调 super 方法
有时候 override 一个方法，主要目的是在 super 方法之前做一些准备工作，比如 UICollectionViewLayout 的 prepare(forCollectionViewUpdates:)，那么我们就可以把调用 super 的部分放在 defer 里：
func override foo() {
defer {
super.foo()
}
// some preparation before super.foo()...
}
一些细节
任意 scope 都可以有 defer
虽然大部分的使用场景是在函数里，不过理论上任何一个 { } 之间都是可以写 defer 的。比如一个普通的循环：
var sumOfOdd = 0
for i in 0...10 {
defer {
print("Look! It's \(i)")
}
if i % 2 == 0 {
continue
}
sumOfOdd += i
}
continue 或者 break 都不会妨碍 defer 的执行。甚至 closure 里也可以写 defer：
{
defer { print("bye!") }
print("hello!")
}
只不过 这样没什么意义……
必须执行到 defer 才会触发
假设有这样一个问题：一个 scope 里的 defer 能保证一定会执行吗？
答案 NO……比如下面这个例子：
func foo() throws {
do {
throw NSError()
print("impossible")
}
defer {
print("finally")
}
}
try?foo()
不会执行 defer，不会 print 任何东西。这个故事告诉我们，至少要执行到 defer 这一行，它才保证后面会触发。同样道理提前 return 也是一样不行的：
func foo() {
guard false else { return }
defer {
print("finally")
}
}
多个 defer
一个 scope 可以有多个 defer，顺序是像栈一样FIFO执行的：每遇到一个 defer 就像压进一个栈里，到 scope 结束的时候，后进栈的先执行。如下面的代码，会按 1、2、3、4、5、6 的顺序 print 出来。
func foo() {
print("1")
defer {
print("6")
}
print("2")
defer {
print("5")
}
print("3")
defer {
print("4")
}
}
网友评论