準(zhǔn)備把 swift 文檔再掃一遍，發(fā)現(xiàn)了defer這個(gè)關(guān)鍵字，恕本人愚鈍，以前還從來(lái)沒(méi)有用過(guò)這個(gè)呢~ 簡(jiǎn)單地列一下這個(gè)東西有哪些可以用得上的情景吧~~

defer 是干什么用的

很簡(jiǎn)單，用一句話(huà)概括，就是 defer block 里的代碼會(huì)在函數(shù) return 之前執(zhí)行，無(wú)論函數(shù)是從哪個(gè)分支 return 的，還是有 throw，還是自然而然走到最后一行。

這個(gè)關(guān)鍵字就跟 Java 里的 try-catch-finally 的finally一樣，不管 try catch 走哪個(gè)分支，它都會(huì)在函數(shù) return 之前執(zhí)行。而且它比 Java 的finally還更強(qiáng)大的一點(diǎn)是，它可以獨(dú)立于 try catch 存在，所以它也可以成為整理函數(shù)流程的一個(gè)小幫手。在函數(shù) return 之前無(wú)論如何都要做的處理，可以放進(jìn)這個(gè) block 里，讓代碼看起來(lái)更干凈一些~

下面是 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)

這個(gè)例子里執(zhí)行的順序是，先fridgeIsOpen = true，然后是函數(shù)體正常的流程，最后在 return 之前執(zhí)行 fridgeIsOpen = false。

幾個(gè)簡(jiǎn)單的使用場(chǎng)景

try catch 結(jié)構(gòu)

最典型的場(chǎng)景，我想也是 defer 這個(gè)關(guān)鍵字誕生的主要原因吧：

func foo() {
  defer {
    print("finally")
  }
  do {
    throw NSError()
    print("impossible")
  } catch {
    print("handle error")
  }
}

不管 do block 是否 throw error，有沒(méi)有 catch 到，還是 throw 出去了，都會(huì)保證在整個(gè)函數(shù) return 前執(zhí)行 defer。在這個(gè)例子里，就是先 print 出 "handle error" 再 print 出 "finally"。

do block 里也可以寫(xiě) defer：

do {
  defer {
    print("finally")
  }
  throw NSError()
  print("impossible")
} catch {
  print("handle error")
}

那么它執(zhí)行的順序就會(huì)是在 catch block 之前，也就是先 print 出 "finally" 再 print 出 "handle error"。

清理工作、回收資源

跟 swift 文檔舉的例子類(lèi)似，defer一個(gè)很適合的使用場(chǎng)景就是用來(lái)做清理工作。文件操作就是一個(gè)很好的例子：

關(guān)閉文件

func foo() {
  let fileDescriptor = open(url.path, O_EVTONLY)
  defer {
    close(fileDescriptor)
  }
  // use fileDescriptor...
}

這樣就不怕哪個(gè)分支忘了寫(xiě)，或者中間 throw 個(gè) error，導(dǎo)致 fileDescriptor 沒(méi)法正常關(guān)閉。還有一些類(lèi)似的場(chǎng)景：

dealloc 手動(dòng)分配的空間

func foo() {
  let valuePointer = UnsafeMutablePointer<T>.allocate(capacity: 1)
  defer {
    valuePointer.deallocate(capacity: 1)
  }
  // use pointer...
}

加/解鎖：下面是 swift 里類(lèi)似 Objective-C 的 synchronized block 的一種寫(xiě)法，可以使用任何一個(gè) NSObject 作 lock

func foo() {
  objc_sync_enter(lock)
  defer { 
    objc_sync_exit(lock)
  }
  // do something...
}

像這種成對(duì)調(diào)用的方法，可以用 defer 把它們放在一起，一目了然。

調(diào) completion block

這是一個(gè)讓我感覺(jué)“如果當(dāng)時(shí)知道 defer ”就好了的場(chǎng)景，就是有時(shí)候一個(gè)函數(shù)分支比較多，可能某個(gè)小分支 return 之前就忘了調(diào) completion block，結(jié)果藏下一個(gè)不易發(fā)現(xiàn)的 bug。用 defer 就可以不用擔(dān)心這個(gè)問(wèn)題了：

func foo(completion: () -> Void) {
  defer {
    self.isLoading = false
    completion()
  }
  guard error == nil else { return } 
  // handle success
}

有時(shí)候 completion 要根據(jù)情況傳不同的參數(shù)，這時(shí) defer 就不好使了。不過(guò)如果 completion block 被存下來(lái)了，我們還是可以用它來(lái)確保執(zhí)行后能釋放：

func foo() {
  defer {
    self.completion = nil
  }
  if (succeed) {
    self.completion(.success(result))
  } else {
    self.completion(.error(error))
  }
}

調(diào) super 方法

有時(shí)候 override 一個(gè)方法，主要目的是在 super 方法之前做一些準(zhǔn)備工作，比如 UICollectionViewLayout 的 prepare(forCollectionViewUpdates:)，那么我們就可以把調(diào)用 super 的部分放在 defer 里：

func override foo() {
  defer {
    super.foo()
  }
  // some preparation before super.foo()...
}

一些細(xì)節(jié)

任意 scope 都可以有 defer

雖然大部分的使用場(chǎng)景是在函數(shù)里，不過(guò)理論上任何一個(gè) { } 之間都是可以寫(xiě) defer 的。比如一個(gè)普通的循環(huán)：

var sumOfOdd = 0
for i in 0...10 {
  defer {
    print("Look! It's \(i)")
  }
  if i % 2 == 0 {
    continue
  }
  sumOfOdd += i
}

continue 或者 break 都不會(huì)妨礙 defer 的執(zhí)行。甚至一個(gè)平白無(wú)故的 closure 里也可以寫(xiě) defer：

{
  defer { print("bye!") }
  print("hello!")
}

就是這樣沒(méi)什么意義就是了……

必須執(zhí)行到 defer 才會(huì)觸發(fā)

假設(shè)有這樣一個(gè)問(wèn)題：一個(gè) scope 里的 defer 能保證一定會(huì)執(zhí)行嗎？
答案是否……比如下面這個(gè)例子：

func foo() throws {
  do {
    throw NSError()
    print("impossible")
  }
  defer {
    print("finally")
  }
}
try?foo()

不會(huì)執(zhí)行 defer，不會(huì) print 任何東西。這個(gè)故事告訴我們，至少要執(zhí)行到 defer 這一行，它才保證后面會(huì)觸發(fā)。同樣道理，提前 return 也是一樣不行的：

func foo() {
  guard false else { return }
  defer {
    print("finally")
  }
}

多個(gè) defer

一個(gè) scope 可以有多個(gè) defer，順序是像棧一樣倒著執(zhí)行的：每遇到一個(gè) defer 就像壓進(jìn)一個(gè)棧里，到 scope 結(jié)束的時(shí)候，后進(jìn)棧的先執(zhí)行。如下面的代碼，會(huì)按 1、2、3、4、5、6 的順序 print 出來(lái)。

func foo() {
  print("1")
  defer {
    print("6")
  }
  print("2")
  defer {
    print("5")
  }
  print("3")
  defer {
    print("4")
  }
}

但是我強(qiáng)烈建議不要這么寫(xiě)。我是建議一個(gè) scope 里不要有多個(gè) defer，感覺(jué)除了讓讀代碼的人感覺(jué)混亂之外沒(méi)有什么好處。

參考資料

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