swift 的 defer 几个简单的使用场景

准备把 swift 文档再扫一遍，发现了defer这个关键字，恕本人愚钝，之前还历来没有用过这个呢~ 简单地列一下这个东西有哪些能够用得上的情景吧~~

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<T>.allocate(capacity: 1)
  defer {
    valuePointer.deallocate(capacity: 1)
  }
  // use pointer...
}
复制代码

加/解锁：下面是 swift 里相似 Objective-C 的 synchronized block 的一种写法，可使用任何一个 NSObject 做 lock

func foo() {
  objc_sync_enter(lock)
  defer { 
    objc_sync_exit(lock)
  }
  // do something...
}
复制代码

像这种成对调用的方法，能够用 defer 把它们放在一块儿，一目了然。

调 completion block

这是一个让我感受“若是当时知道 defer ”就行了的场景，就是有时候一个函数分支比较多，可能某个小分支 return 以前就忘了调 completion block，结果藏下一个不易发现的 bug。用 defer 就能够不用担忧这个问题了：

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 能保证必定会执行吗？ 答案是否……好比下面这个例子：

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，顺序是像栈同样倒着执行的：每遇到一个 defer 就像压进一个栈里，到 scope 结束的时候，后进栈的先执行。以下面的代码，会按 一、二、三、四、五、6 的顺序 print 出来。

func foo() {
  print("1")
  defer {
    print("6")
  }
  print("2")
  defer {
    print("5")
  }
  print("3")
  defer {
    print("4")
  }
}
复制代码

可是我强烈建议不要这么写。我是建议一个 scope 里不要有多个 defer，感受除了让读代码的人感受混乱以外没有什么好处。

参考资料

What is the Swift equivalent to Objective-C's “@synchronized”?