Swift 中 defer 的介绍与使用场景

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

例如：你可以用defer语句来确保文件描述符得以关闭，以及手动分配的内存得以释放。

defer语句将代码的执行延迟到当前的作用域退出之前。该语句由defer关键字和要被延迟的语句组成。延迟执行的语句不能包括任何控制转移语句，例如break，return语句，或是抛出一个错误，延迟执行的操作会按照它们声明的顺序从后往前执行---也就是说，第一条defer语句中的代码最后才执行，第二条defer语句中的代码倒数第二个执行，以此类推，最后一条语句会第一个执行。

defer 语句在代码块（方法，闭包等，可以理解为大括号包装起来的代码）作用域退出之前执行，也就是代码块中其他代码该执行的都执行完了，才执行defer中的代码一个代码块允许多个defer，多个defer执行的顺序从后到前。

测试案例1

func testDefer() {
    defer {
        print("方法中defer内容") // 4
    }
    if true {
        defer {
            print("if 中defer内容") // 2
        }
        print("if中最后的代码") // 1 
    }
    print("方法中的代码") // 3
    if true {
        return
    }
    print("方法结束前最后一句代码") // 前面return 掉了 这里不执行
}

testDefer()


执行结果
if中最后的代码
if 中defer内容
方法中的代码
方法中defer内容

打印结果中，第一个 if true 中的代码块先执行（if中的 最后的代码先执行，然后是 if中的 defer 代码块），然后是 if下方的 方法中的代码执行，最后执行testDefer方法中的 defer 代码块。

由此可以看出，代码块中其他能够执行的代码先执行，最后执行defer的内容；defer的作用范围不能简单的看成方法，而是代码块

测试案例2

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

结果
开始
方法中的代码
defer 2 中的内容
defer 1 中的内容

我们可以看出 if true 之后的代码 都没有执行，包括最后一个 defer 3 也没有执行，所以defer定义的位置很重要，如果没有执行defer定义的代码，在代码块结束前，不会执行defer中的内容。
注意：多个defer的执行顺序从后到前

一些实际应用场景

场景1 - 一些资源用完后需要释放，这里给的是官方的一个案例

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

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

场景2 - 加锁解锁，借鉴了 kingfisher

let lock = NSLock()
func testDefer() {
    lock.lock()
    defer {
        lock.unlock()
    }
    print("doSomething。。。")
}
testDefer()

在加锁后，添加defer代码解锁，避免忘记解锁。

场景3 - 处理一些代码块作用域结束前的重复操作，如调 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))
  }
}

场景4 调用supper方法

有时候 override 一个方法， 主要目的是在super方法之前做一些准备工作，我们就可以把调用 super 的部分放在 defer 里面：

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

建议：最好不要加多个 defer 否则逻辑更加会显着比较混乱。

大家多喝热水，最近天真干。