swift学习之defer用法

一，概述

• 官方说明

  用 defer 语句在即将离开当前代码块时执行一系列语句。该语句让你能执行一些必要的清理工作，不管是以何种方式离开当前代码块的——无论是由于抛出错误而离开，或是由于诸如 return、break 的语句。

  例如，你可以用 defer 语句来确保文件描述符得以关闭，以及手动分配的内存得以释放。 defer 语句将代码的执行延迟到当前的作用域退出之前。该语句由 defer 关键字和要被延迟执行的语句组成。延迟执行的语句不能包含任何控制转移语句，例如 break、return 语句，或是抛出一个错误。

  延迟执行的操作会按照它们声明的顺序从后往前执行——也就是说，第一条 defer 语句中的代码最后才执行，第二条 defer 语句中的代码倒数第二个执行，以此类推。最后一条语句会第一个执行。

• 简单概括

  defer语句在代码块（方法、闭包等，可以理解为大括号包装起来的代码）作用域退出之前执行，也就是代码块中其他应该执行的代码都执行完了，才执行defer中的代码

  一个代码块允许多个defer，多个defer执行的顺序从后到前

• 文档示例
  

  ///官方示例
  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。

二，测试示例

• 示例一（任意 scope 都可以有 defer）

  ///测试方法
  func testDefer() {
      print("方法开始执行")
      var sumOfOdd = 0
      for i in 0...3 {
          defer {
              print("Look! It's \(i)")
          }
          if i % 2 == 0 {
              continue
          }
          sumOfOdd += i
      }
      print("方法执行完成")
  }
  
  ///调用方法
  testDefer()

  以上代码打印结果：

  方法开始执行
  Look! It's 0
  Look! It's 1
  Look! It's 2
  Look! It's 3
  方法执行完成

  结果分析：

  虽然大部分的使用场景是在函数里，不过理论上任何一个 { } 之间都是可以写 defer 的。比如一个普通的循环。

  continue 或者 break 都不会妨碍 defer 的执行。

• 示例二（多个 defer）

  ///测试方法
  func testDefer(){
      defer {
          print("1:方法中defer内容")
      }
      
      if true {
          defer {
              print("2:if中的defer内容")
          }
          print("3:if中最后的代码")
      }
      
      print("4:方法中的代码")
      
      if true {
          return
      }
      
      print("5:方法结束前最后一句话")
  }
  
  ///调用
  testDefer()

  以上代码打印结果：

  3:if中最后的代码
  2:if中的defer内容
  4:方法中的代码
  1:方法中defer内容

  结果分析：

  打印结果中，第一个if中的代码及里面的defer最先执行，方法中的defer最后执行，由此可以看出，代码块中其他能够执行的代码先执行，最后执行defer的内容；defer的作用范围不能简单的看成方法，而是代码块（可能有些同学会有这样的误区）

• 示例三（必须执行到 defer 才会触发）

  ///测试方法
  func testDefer() {
      print("1:开始")
      
      defer {
          print("2:defer 1 中的内容")
      }
      
      defer {
          print("3:defer 2 中的内容")
      }
      
      if true {
          return
      }
      
      defer {
          print("4:defer 3 中的内容")
      }
      
      print("5:方法结束前最后一句代码")
  }
  
  ///调用方法
  testDefer()

  以上代码打印结果：

  1:开始
  3:defer 2 中的内容
  2:defer 1 中的内容

  结果分析：

  我们可以看到最后一个defer没有执行，所以defer定义的位置很重要，如果没有执行defer定义的代码，在代码块结束前不会执行defer中的内容 多个defer的执行顺序从后到前

三，一些实际应用场景

• try catch 结构

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

  以上代码打印结果：


  handle error
  finally

  结果分析：

  不管 do catch 是否 throw error，有没有 catch 到，还是 throw 出去了，都会保证在整个函数 return 前执行 defer。在这个例子里，就是先 print 出 "handle error" 再 print 出 "finally"。

• 清理工作、回收资源

  跟 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 把它们放在一起，一目了然。

  • 一些资源用完后需释放，这里给的是官方的一个案例
    

    func processFile(filename: String) throws {
        if exists(filename) {
            let file = open(filename)
            defer {
                close(file)
            }
            while let line = try file.readline() {
                // 处理文件。
            }
            // close(file) 会在这里被调用，即作用域的最后。
        }
    }

    开始用到资源的时候就使用defer去释放，避免忘记释放资源

• 调 super 方法

  有时候override 一个方法，主要目的是在 super 方法之前做一些准备工作，比如 UICollectionViewLayout 的prepare(forCollectionViewUpdates:)，那么我们就可以把调用 super 的部分放在 defer 里：

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

• 调 completion block

  处理一些代码块作用域结束前的重复操作，比如请求网络数据的时候

  通常的一种写法

  func loadCityList(_ finish: ((Error?, [String]?) -> ())?) {
      DispatchQueue.global().async { // 模拟网络请求
          let data: AnyObject? // 模拟服务器返回的数据
          guard let dict = data as? [String: AnyObject] else {
              DispatchQueue.main.async {
                  finish?(error, nil)
              }
              return
          }
          guard let code = dict["code"] as? Int, code == 200 else {
              DispatchQueue.main.async {
                  finish?(error, nil)
              }
              return
          }
          guard let citys = dict["data"] as? [String]? else {
              DispatchQueue.main.async {
                  finish?(error, nil)
              }
              return
          }
          DispatchQueue.main.async {
              finish?(nil, citys)
          }
      }
  }

  当每次有错误处理时和结果正确时都需要去做回调，而且回调可能有一堆代码，看起来代码会比较冗余，而且在一些错误处理时很容易造成忘记回调

  defer怎么去写呢

  func loadCityList(_ finish: ((Error?, [String]?) -> ())?) {
      DispatchQueue.global().async { // 模拟网络请求
          var error: Error? = nil
          var citys: [String]? = nil
          defer {
              DispatchQueue.main.async {
                  finish?(error, citys)
              }
          }
          
          let data: AnyObject? // 模拟服务器返回的数据
          guard let dict = data as? [String: AnyObject] else {
              error = ...
              return
          }
          guard let code = dict["code"] as? Int, code == 200 else {
              error = ...
              return
          }
          guard let tempCitys = dict["data"] as? [String]? else {
              error = ...
              return
          }
          citys = tempCitys
      }
  }

  使用defer既解决了代码冗余，又解决了可能忘记回调的问题，还有当我们看到defer时，我们很清楚知道，无论网络请求结果如何，都会回调