错误处理

2.1
翻译+校对：lyojo ray16897188 2015-10-23
校对：shanks 2015-10-24

2.2
翻译+校对：SketchK 2016-05-15

3.0
翻译+校对：shanks 2016-09-24
3.0.1，shanks，2016-11-13

4.0
翻译+校对：kemchenj 2017-09-21

本页包含内容：

错误处理（Error handling）是响应错误以及从错误中恢复的过程。Swift 提供了在运行时对可恢复错误的抛出、捕获、传递和操作的一等公民支持。

某些操作无法保证总是执行完所有代码或总是生成有用的结果。可选类型可用来表示值缺失，但是当某个操作失败时，最好能得知失败的原因，从而可以作出相应的应对。

举个例子，假如有个从磁盘上的某个文件读取数据并进行处理的任务，该任务会有多种可能失败的情况，包括指定路径下文件并不存在，文件不具有可读权限，或者文件编码格式不兼容。区分这些不同的失败情况可以让程序解决并处理某些错误，然后把它解决不了的错误报告给用户。

注意
Swift 中的错误处理涉及到错误处理模式，这会用到 Cocoa 和 Objective-C 中的NSError。关于这个类的更多信息请参见 Using Swift with Cocoa and Objective-C (Swift 4) 中的错误处理。

表示并抛出错误

在 Swift 中，错误用符合Error协议的类型的值来表示。这个空协议表明该类型可以用于错误处理。

Swift 的枚举类型尤为适合构建一组相关的错误状态，枚举的关联值还可以提供错误状态的额外信息。例如，你可以这样表示在一个游戏中操作自动贩卖机时可能会出现的错误状态：

  1. enum VendingMachineError: Error {
  2.     case invalidSelection                     //选择无效
  3.     case insufficientFunds(coinsNeeded: Int) //金额不足
  4.     case outOfStock                             //缺货
  5. }

抛出一个错误可以让你表明有意外情况发生，导致正常的执行流程无法继续执行。抛出错误使用throw关键字。例如，下面的代码抛出一个错误，提示贩卖机还需要5个硬币：

  1. throw VendingMachineError. insufficientFunds(coinsNeeded: 5)

处理错误

某个错误被抛出时，附近的某部分代码必须负责处理这个错误，例如纠正这个问题、尝试另外一种方式、或是向用户报告错误。

Swift 中有4种处理错误的方式。你可以把函数抛出的错误传递给调用此函数的代码、用do-catch语句处理错误、将错误作为可选类型处理、或者断言此错误根本不会发生。每种方式在下面的小节中都有描述。

当一个函数抛出一个错误时，你的程序流程会发生改变，所以重要的是你能迅速识别代码中会抛出错误的地方。为了标识出这些地方，在调用一个能抛出错误的函数、方法或者构造器之前，加上try关键字，或者try?或try!这种变体。这些关键字在下面的小节中有具体讲解。

注意
Swift 中的错误处理和其他语言中用try，catch和throw进行异常处理很像。和其他语言中（包括 Objective-C ）的异常处理不同的是，Swift 中的错误处理并不涉及解除调用栈，这是一个计算代价高昂的过程。就此而言，throw语句的性能特性是可以和return语句相媲美的。

用 throwing 函数传递错误

为了表示一个函数、方法或构造器可以抛出错误，在函数声明的参数列表之后加上throws关键字。一个标有throws关键字的函数被称作throwing 函数。如果这个函数指明了返回值类型，throws关键词需要写在箭头（->）的前面。

  1. func canThrowErrors() throws -> String
  2. func cannotThrowErrors() -> String

一个 throwing 函数可以在其内部抛出错误，并将错误传递到函数被调用时的作用域。

注意
只有 throwing 函数可以传递错误。任何在某个非 throwing 函数内部抛出的错误只能在函数内部处理。

下面的例子中，VendingMachine类有一个vend(itemNamed:)方法，如果请求的物品不存在、缺货或者投入金额小于物品价格，该方法就会抛出一个相应的VendingMachineError：

  1. struct Item {
  2.     var price: Int
  3.     var count: Int
  4. }
  6. class VendingMachine {
  7.     var inventory = [
  8.         "Candy Bar": Item(price: 12, count: 7),
  9.         "Chips": Item(price: 10, count: 4),
  10.         "Pretzels": Item(price: 7, count: 11)
  11.     ]
  12.     var coinsDeposited = 0
  13.     func dispenseSnack(snack: String) {
  14.         print("Dispensing \(snack)")
  15.     }
  17.     func vend(itemNamed name: String) throws {
  18.         guard let item = inventory[name] else {
  19.             throw VendingMachineError.invalidSelection
  20.         }
  22.         guard item.count > 0 else {
  23.             throw VendingMachineError.outOfStock
  24.         }
  26.         guard item.price <= coinsDeposited else {
  27.             throw VendingMachineError.insufficientFunds(coinsNeeded: item.price - coinsDeposited)
  28.         }
  30.         coinsDeposited -= item.price
  32.         var newItem = item
  33.         newItem.count -= 1
  34.         inventory[name] = newItem
  36.         print("Dispensing \(name)")
  37.     }
  38. }

在vend(itemNamed:)方法的实现中使用了guard语句来提前退出方法，确保在购买某个物品所需的条件中，有任一条件不满足时，能提前退出方法并抛出相应的错误。由于throw语句会立即退出方法，所以物品只有在所有条件都满足时才会被售出。

因为vend(itemNamed:)方法会传递出它抛出的任何错误，在你的代码中调用此方法的地方，必须要么直接处理这些错误——使用do-catch语句，try?或try!；要么继续将这些错误传递下去。例如下面例子中，buyFavoriteSnack(person:vendingMachine:)同样是一个 throwing 函数，任何由vend(itemNamed:)方法抛出的错误会一直被传递到buyFavoriteSnack(person:vendingMachine:)函数被调用的地方。

  1. let favoriteSnacks = [
  2.     "Alice": "Chips",
  3.     "Bob": "Licorice",
  4.     "Eve": "Pretzels",
  5. ]
  6. func buyFavoriteSnack(person: String, vendingMachine: VendingMachine) throws {
  7.     let snackName = favoriteSnacks[person] ?? "Candy Bar"
  8.     try vendingMachine.vend(itemNamed: snackName)
  9. }

上例中，buyFavoriteSnack(person:vendingMachine:)函数会查找某人最喜欢的零食，并通过调用vend(itemNamed:)方法来尝试为他们购买。因为vend(itemNamed:)方法能抛出错误，所以在调用的它时候在它前面加了try关键字。

throwing构造器能像throwing函数一样传递错误。例如下面代码中的PurchasedSnack构造器在构造过程中调用了throwing函数，并且通过传递到它的调用者来处理这些错误。 

  1. struct PurchasedSnack {
  2.     let name: String
  3.     init(name: String, vendingMachine: VendingMachine) throws {
  4.         try vendingMachine.vend(itemNamed: name)
  5.         self.name = name
  6.     }
  7. }

用 Do-Catch 处理错误

可以使用一个do-catch语句运行一段闭包代码来处理错误。如果在do子句中的代码抛出了一个错误，这个错误会与catch子句做匹配，从而决定哪条子句能处理它。

下面是do-catch语句的一般形式：

  1. do {
  2.     try expression
  3.     statements
  4. } catch pattern 1 {
  5.     statements
  6. } catch pattern 2 where condition {
  7.     statements
  8. }

在catch后面写一个匹配模式来表明这个子句能处理什么样的错误。如果一条catch子句没有指定匹配模式，那么这条子句可以匹配任何错误，并且把错误绑定到一个名字为error的局部常量。关于模式匹配的更多信息请参考 模式。

catch子句不必将do子句中的代码所抛出的每一个可能的错误都作处理。如果所有catch子句都未处理错误，错误就会传递到周围的作用域。然而，错误还是必须要被某个周围的作用域处理的——要么是一个外围的do-catch错误处理语句，要么是一个 throwing 函数的内部。举例来说，下面的代码处理了VendingMachineError枚举类型的全部枚举值，但是所有其它的错误就必须由它周围的作用域处理：

  1. var vendingMachine = VendingMachine()
  2. vendingMachine.coinsDeposited = 8
  3. do {
  4.     try buyFavoriteSnack(person: "Alice", vendingMachine: vendingMachine)
  5. } catch VendingMachineError.invalidSelection {
  6.     print("Invalid Selection.")
  7. } catch VendingMachineError.outOfStock {
  8.     print("Out of Stock.")
  9. } catch VendingMachineError.insufficientFunds(let coinsNeeded) {
  10.     print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.")
  11. }
  12. // 打印 “Insufficient funds. Please insert an additional 2 coins.”

上面的例子中，buyFavoriteSnack(person:vendingMachine:)函数在一个try表达式中调用，因为它能抛出错误。如果错误被抛出，相应的执行会马上转移到catch子句中，并判断这个错误是否要被继续传递下去。如果没有错误抛出，do子句中余下的语句就会被执行。

将错误转换成可选值

可以使用try?通过将错误转换成一个可选值来处理错误。如果在评估try?表达式时一个错误被抛出，那么表达式的值就是nil。例如，在下面的代码中，x和y有着相同的数值和等价的含义：

  1. func someThrowingFunction() throws -> Int {
  2.     // ...
  3. }
  5. let x = try? someThrowingFunction()
  7. let y: Int?
  8. do {
  9.     y = try someThrowingFunction()
  10. } catch {
  11.     y = nil
  12. }

如果someThrowingFunction()抛出一个错误，x和y的值是nil。否则x和y的值就是该函数的返回值。注意，无论someThrowingFunction()的返回值类型是什么类型，x和y都是这个类型的可选类型。例子中此函数返回一个整型，所以x和y是可选整型。

如果你想对所有的错误都采用同样的方式来处理，用try?就可以让你写出简洁的错误处理代码。例如，下面的代码用几种方式来获取数据，如果所有方式都失败了则返回nil。

  1. func fetchData() -> Data? {
  2.     if let data = try? fetchDataFromDisk() { return data }
  3.     if let data = try? fetchDataFromServer() { return data }
  4.     return nil
  5. }

禁用错误传递

有时你知道某个throwing函数实际上在运行时是不会抛出错误的，在这种情况下，你可以在表达式前面写try!来禁用错误传递，这会把调用包装在一个不会有错误抛出的运行时断言中。如果真的抛出了错误，你会得到一个运行时错误。

例如，下面的代码使用了loadImage(atPath:)函数，该函数从给定的路径加载图片资源，如果图片无法载入则抛出一个错误。在这种情况下，因为图片是和应用绑定的，运行时不会有错误抛出，所以适合禁用错误传递。

  1. let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")

指定清理操作

可以使用defer语句在即将离开当前代码块时执行一系列语句。该语句让你能执行一些必要的清理工作，不管是以何种方式离开当前代码块的——无论是由于抛出错误而离开，或是由于诸如return、break的语句。例如，你可以用defer语句来确保文件描述符得以关闭，以及手动分配的内存得以释放。

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

  1. func processFile(filename: String) throws {
  2.     if exists(filename) {
  3.         let file = open(filename)
  4.         defer {
  5.             close(file)
  6.         }
  7.         while let line = try file.readline() {
  8.             // 处理文件。
  9.         }
  10.         // close(file) 会在这里被调用，即作用域的最后。
  11.     }
  12. }

上面的代码使用一条defer语句来确保open(_:)函数有一个相应的对close(_:)函数的调用。

注意
即使没有涉及到错误处理，你也可以使用defer语句。