第17章：错误处理

  错误处理是响应程序中的错误并从中恢复的过程。Swift为在运行时抛出，捕获，传播和操纵可恢复的错误提供了一流的支持。
  某些操作无法保证始终完成执行或生成有用的输出。Optionals用于表示缺少值，但是当操作失败时，了解导致失败的原因通常很有用，这样您的代码就可以做出相应的响应。
  例如，考虑从磁盘上的文件读取和处理数据的任务。此任务可能有多种失败方式，包括指定路径中不存在的文件，没有读取权限的文件或未以兼容格式编码的文件。区分这些不同的情况允许程序解决一些错误并向用户传达它无法解决的任何错误。

17.1 表示与抛出错误

注意
在Swift中，错误由符合Error协议的类型的值表示。此空协议表示类型可用于错误处理。

  Swift枚举特别适合于对一组相关错误条件进行建模，其中关联的值含有相关传达的错误性质的附加信息。例如，以下是表示在游戏中操作自动售货机的错误条件：

enum VendingMachineError: Error {
    case invalidSelection
    case insufficientFunds(coinsNeeded: Int)
    case outOfStock
}

  抛出错误可以指示发生了意外情况，并且正常的执行流程无法继续。使用throw语句来抛出错误。例如，以下代码抛出一个错误，表示自动售货机需要五个额外的硬币：

throw VendingMachineError.insufficientFunds(coinsNeeded: 5)

17.2 处理错误

  当抛出错误时，一些周围的代码必须负责处理错误 - 例如，通过纠正问题，尝试替代方法或通知用户失败。
  有四种方法可以处理Swift中的错误。您可以将错误从函数传播到调用该函数的代码，使用do- catch语句处理错误，将错误作为可选值处理，或断言错误不会发生。每种方法都在下面的部分中描述。
  当函数抛出错误时，它会改变程序的流程，因此您可以快速识别代码中可能引发错误的位置，这一点很重要。要在代码中标识这些位置，请在调用可能引发错误的函数，方法或初始化程序的代码之前编写try关键字 - 或者try?或try!变体。这些关键字在以下部分中描述。

注意
在Swift的错误处理类似其他语言中使用try，catch和throw关键字的异常处理。与许多语言中的异常处理不同—包括Objective-C—处理不涉及展开调用堆栈，这可能是计算上昂贵的过程。因此，throw性能特征与return的性能特征类似。

17.2.1 抛出错误

  要指示函数，方法或初始值设定项可以抛出错误，把throws放在函数声明的括号后面。含有throws声明的函数称之为可能抛出错误的函数。如果函数指定了返回类型，则throws在返回箭头（->）之前。

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

  抛出函数将抛出其中的错误传播到调用它的范围。
  在下面的示例中，VendingMachine类具有一个vend(itemNamed:)方法，如果请求的项目不可用，缺货或成本超过当前存入的金额，则抛出适当的方法：

struct Item {
    var price: Int
    var count: Int
}

class VendingMachine {
    var inventory = [
        "Candy Bar": Item(price: 12, count: 7),
        "Chips": Item(price: 10, count: 4),
        "Pretzels": Item(price: 7, count: 11)
    ]
    var coinsDeposited = 0

    func vend(itemNamed name: String) throws {
        guard let item = inventory[name] else {
            throw VendingMachineError.invalidSelection
        }

        guard item.count > 0 else {
            throw VendingMachineError.outOfStock
        }

        guard item.price <= coinsDeposited else {
            throw VendingMachineError.insufficientFunds(coinsNeeded: item.price - coinsDeposited)
        }

        coinsDeposited -= item.price

        var newItem = item
        newItem.count -= 1
        inventory[name] = newItem

        print("Dispensing \(name)")
    }
}

  该vend(itemNamed:)方法的实现使用guard语句提前退出方法，并且如果不满足购买零食的任何要求则抛出适当的错误。由于throw语句会立即转移程序控制，因此只有满足所有这些要求才会销售项目。
  因为该vend(itemNamed:)方法传播它抛出的任何错误，所以调用此方法的任何代码都必须使用do- catch语句处理错误try?，或者try!- 或继续传播它们。例如，buyFavoriteSnack(person:vendingMachine:)下面的示例中也是一个抛出函数，并且该vend(itemNamed:)方法抛出的任何错误都将传播到buyFavoriteSnack(person:vendingMachine:)调用函数的位置。

let favoriteSnacks = [
    "Alice": "Chips",
    "Bob": "Licorice",
    "Eve": "Pretzels",
]
func buyFavoriteSnack(person: String, vendingMachine: VendingMachine) throws {
    let snackName = favoriteSnacks[person] ?? "Candy Bar"
    try vendingMachine.vend(itemNamed: snackName)
}

  在此示例中，该函数查找给定人员最喜欢的零食并尝试通过调用该方法为他们购买。因为该方法可以抛出错误，所以在它前面添加关键字try。
  初始化器可以像函数一样抛出错误。例如，PurchasedSnack下面列表中结构的初始化程序将throw函数作为初始化过程的一部分调用，它通过将它们传播给调用者来处理它遇到的任何错误。

struct PurchasedSnack {
    let name: String
    init(name: String, vendingMachine: VendingMachine) throws {
        try vendingMachine.vend(itemNamed: name)
        self.name = name
    }
}

17.2.2 使用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 {
9.    statements
10.  }

  之后编写一个模式catch以指示该子句可以处理的错误。如果catch子句没有模式，则该子句匹配任何错误并将错误绑定到名为的本地常量error。
  例如，以下代码匹配VendingMachineError枚举的所有三种情况。

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

  在上面的示例中，buyFavoriteSnack(person:vendingMachine:)函数在try表达式中调用，因为它可能会抛出错误。如果抛出错误，则执行立即转移到catch子句，该子句决定是否允许传播继续。如果没有匹配模式，则错误会被final catch子句捕获并绑定到本地error常量。如果未引发错误，do则执行语句中的其余语句。
  这些catch子句不必处理do子句中的代码可能抛出的每个可能的错误。如果没有catch子句处理错误，则错误将传播到周围的范围。但是，传播的错误必须由某些周围的范围处理。在非throwing函数中，enclosing do- catch子句必须处理错误。在投掷功能，无论是一个封闭do- catch子句或调用者必须处理错误。如果错误传播到顶级作用域而未进行处理，则会出现运行时错误。
  例如，可以编写上面的示例，以便VendingMachineError调用函数捕获任何非的错误：

1.  func nourish(with item: String) throws {
2.    do {
3.      try vendingMachine.vend(itemNamed: item)
4.    } catch is VendingMachineError {
5.      print("Invalid selection, out of stock, or not enough money.")
6.    }
7.  }

9.  do {
10.    try nourish(with: "Beet-Flavored Chips")
11.  } catch {
12.    print("Unexpected non-vending-machine-related error: \(error)")
13.  }
14.  // Prints "Invalid selection, out of stock, or not enough money."

  在nourish(with:)函数中，如果vend(itemNamed:)抛出的错误是VendingMachineError枚举的一种情况，则nourish(with:)通过打印消息来处理错误。否则，nourish(with:)将错误传播到其调用站点。然后由general catch子句捕获该错误。

17.2.3 将错误转换为可选值

  可以try?通过将错误转换为可选值来处理错误。如果在计算try?表达式时抛出错误，则表达式的值为nil。例如，在下面的代码x，并y具有相同的价值和行为：

func someThrowingFunction() throws -> Int {
    // ...
}

let x = try? someThrowingFunction()

let y: Int?
do {
    y = try someThrowingFunction()
} catch {
    y = nil
}

  如果someThrowingFunction()抛出错误，则为x和的值。否则，和的值是函数返回的值。请注意，并且是任何类型返回的可选项。这里函数返回一个整数，因此它是可选的整数。ynilxyxysomeThrowingFunction()xy
  如果出现错误，则x、y都是nil，如果没有出现错误，x、y将是返回值的可选类型。

func fetchData() -> Data? {
    if let data = try? fetchDataFromDisk() { return data }
    if let data = try? fetchDataFromServer() { return data }
    return nil
}

17.2.4 禁止错误传播

  有时你知道抛出函数或方法实际上不会在运行时抛出错误。在这些情况下，您可以在在表达式之前编写try!以禁用错误传播，并在运行时断言中包装调用，以便不会引发错误。如果实际抛出了错误，您将收到运行时错误。
  例如，以下代码使用一个loadImage(atPath:)函数，该函数在给定路径上加载图像资源，或者如果无法加载图像则抛出错误。在这种情况下，由于映像随应用程序一起提供，因此运行时不会抛出任何错误，因此禁用错误传播是合适的。

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

17.3 延迟清理

  很多时候在执行完一段代码之后需要执行一些特定的语句，例如读写文件之后要关闭文件。这本来是简单的事情，但是由于代码逻辑结构、可能抛出的异常等因素，导致关闭文件的代码散布在方法里的各处且。另外，在需要修改的时候，容易遗漏从而出现问题。
  在Swift中以defer关键字定义的语句块完美解决了以上问题，示例如下。

func processFile(filename: String) throws {
    if exists(filename) {
        let file = open(filename)
        defer {
            close(file)
        }
        while let line = try file.readline() {
            // Work with the file.
        }
        // close(file) is called here, at the end of the scope.
    }
}

  关于defer语句，有以下几点需要注意。

• 此语句允许在离开当前语句块后自动触发调用defer语句，而不论是由于——抛出错误或由于诸如return或之类的语句而离开break。
• 延迟语句可能不包含任何将控制转移出语句的代码，例如a break或return语句，或者抛出错误。
• 延迟操作的执行顺序与它们在源代码中编写的顺序相反。也就是说，第一个defer语句中的代码最后执行，第二个defer语句中的代码执行倒数第二个，依此类推。defer源代码顺序中的最后一个语句首先执行。