17 Error Handling 错误处理

错误处理是响应程序中的错误条件并从中恢复的过程。Swift为在运行时抛出、捕获、传播和操作可恢复错误提供了一流的支持。

有些操作不能保证总是完成执行或生成有用的输出。选项用于表示没有值，但是当操作失败时，了解导致失败的原因通常很有用，这样您的代码就可以相应地作出响应。

例如，考虑从磁盘上的文件中读取和处理数据的任务。此任务失败的原因有很多，包括指定路径上不存在的文件、没有读取权限的文件或没有以兼容格式编码的文件。区分这些不同的情况允许程序解决一些错误，并与用户通信它不能解决的任何错误。

Swift中的错误处理与Cocoa和Objective-C中使用NSError类的错误处理模式进行交互。有关此类的更多信息，请参见 Handling Cocoa Errors in Swift.

Representing and Throwing Errors 表示和抛出错误

在Swift中，错误由符合错误协议的类型值表示。此空协议表示可以使用类型进行错误处理。

Swift枚举特别适合对一组相关错误条件进行建模，相关值允许传递关于错误性质的附加信息。例如，你可以这样表示游戏中操作自动售货机的错误条件:

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

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

throw VendingMachineError.insufficientFunds(coinsNeeded: 5)

Handling Errors 处理错误

当抛出错误时，周围的一些代码必须负责处理错误—例如，通过纠正问题、尝试另一种方法或通知用户错误。

在Swift中有四种处理错误的方法。您可以将错误从函数传播到调用该函数的代码，使用do-catch语句处理错误，将错误作为可选值处理，或者断言错误不会发生。下面一节将描述每种方法。

当一个函数抛出一个错误时，它会改变程序的流程，所以快速识别代码中可能抛出错误的位置非常重要。要识别代码中的这些位置，请编写try关键字或try?或者尝试!变量——在调用可能引发错误的函数、方法或初始化器的代码段之前。下面几节将描述这些关键字。

Swift中的错误处理类似于其他语言中的异常处理，使用try、catch和throw关键字。与许多语言中的异常处理(包括Swift中的objective - c错误处理)不同，Swift中的异常处理不涉及撤销调用堆栈，这一过程的计算代价可能很高。因此，throw语句的性能特征可以与return语句的性能特征进行比较。

Propagating Errors Using Throwing Functions 使用抛出函数传播错误

要指示函数、方法或初始化器可能引发错误，可以在函数的声明中在其参数之后写入throw关键字。用抛出标记的函数称为抛出函数。如果函数指定了返回类型，则在返回箭头(->)之前编写throw关键字。

func canThrowErrors() throws -> String

func cannotThrowErrors() -> String

抛出函数将内部抛出的错误传播到调用它的范围。

只有抛出函数才能传播错误。在非抛出函数中抛出的任何错误都必须在函数中处理。

在下面的例子中，VendingMachine类有一个vend(itemNamed:)方法，如果请求的项目不可用、缺货或成本超过当前存款金额，该方法将抛出一个适当的VendingMachineError:

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语句提前退出方法，如果不满足购买零食的任何要求，则抛出适当的错误。因为抛出语句会立即转移程序控制，所以只有在满足所有这些要求时才会出售项目。

因为vend(itemNamed:)方法传播它抛出的任何错误，所以调用该方法的任何代码都必须处理这些错误——使用do-catch语句，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)
}

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

抛出初始化器可以像抛出函数一样传播错误。例如，下面清单中的PurchasedSnack结构的初始化器调用一个抛出函数作为初始化过程的一部分，并通过将其传播给调用者来处理遇到的任何错误。

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

Handling Errors Using Do-Catch 使用Do-Catch处理错误

您可以使用do-catch语句通过运行一段代码来处理错误。如果do子句中的代码抛出了一个错误，那么它将与catch子句进行匹配，以确定哪个子句可以处理这个错误。

以下是do-catch语句的一般形式:

do {
    try expression
    statements
} catch pattern 1 {
    statements
} catch pattern 2 where condition {
    statements
} catch {
    statements
}

您可以在catch之后编写一个模式来指示子句可以处理哪些错误。如果catch子句没有模式，则子句匹配任何错误并将错误绑定到名为error的本地常量。有关模式匹配的更多信息，请参见 Patterns。

例如，下面的代码匹配VendingMachineError枚举的所有三种情况。

var vendingMachine = VendingMachine()
vendingMachine.coinsDeposited = 8
do {
    try buyFavoriteSnack(person: "Alice", vendingMachine: vendingMachine)
    print("Success! Yum.")
} catch VendingMachineError.invalidSelection {
    print("Invalid Selection.")
} catch VendingMachineError.outOfStock {
    print("Out of Stock.")
} catch VendingMachineError.insufficientFunds(let coinsNeeded) {
    print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.")
} catch {
    print("Unexpected error: \(error).")
}
// Prints "Insufficient funds. Please insert an additional 2 coins."

在上面的例子中，buyFavoriteSnack(person:vendingMachine:)函数在try表达式中被调用，因为它会抛出一个错误。如果抛出错误，执行立即转移到catch子句，该子句决定是否允许继续传播。如果没有匹配模式，则由final catch子句捕获错误，并将其绑定到一个本地错误常量。如果没有抛出错误，则执行do语句中的其余语句。

catch子句不必处理do子句中的代码可能抛出的所有错误。如果catch子句没有处理错误，则错误将传播到周围的范围。但是，传播的错误必须由周围的范围处理。在非抛出函数中，必须包含do-catch子句来处理错误。在抛出函数中，要么包含do-catch子句，要么调用者必须处理错误。如果错误在没有处理的情况下传播到顶层范围，您将得到一个运行时错误。

例如，上面的例子可以这样写，任何不是VendingMachineError的错误都会被调用函数捕获:

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

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

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

Converting Errors to Optional Values 将错误转换为可选值

你通过 用 try? 将错误转换为可选值 来处理错误。如果在计算 try? expression评估表达式的值为nil, 抛出错误。例如，在下面的代码中，x和y具有相同的值和行为:

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

let x = try? someThrowingFunction()

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

如果someThrowingFunction()抛出错误，则x和y的值为nil。否则，x和y的值就是函数返回的值。注意，x和y是someThrowingFunction()返回的任何类型的可选函数。这里函数返回一个整数，所以x和y是可选整数。

当您希望以相同的方式处理所有错误时，用 try? 允许您编写简洁的错误处理代码。例如，下面的代码使用几种方法来获取数据，如果所有方法都失败，则返回nil。

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

Disabling Error Propagation 禁用错误传播

有时，你知道抛出函数或方法在运行时实际上并不会抛出错误。在这些场景，你可以在表达式之前使用 try! 来禁止错误传播并将调用包装在断言中运行 ，断言不会抛出错误，如果实际上发生错误，你会得到一个运行时错误。

例如，下面的代码使用一个loadImage(atPath:)函数，该函数以给定的路径加载图像资源，如果无法加载图像，则抛出一个错误。在本例中，由于应用程序附带了图像，因此在运行时不会抛出错误，因此禁用错误传播是合适的。

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

Specifying Cleanup Actions 指定清理行动

在代码执行离开当前代码块之前，使用deferred语句执行一组语句。该语句允许您执行任何必要的清理工作，无论执行如何离开当前代码块——不管它是由于抛出错误还是由于return或break之类的语句而离开的——都应该执行这些清理工作。例如，可以使用deferred语句确保关闭文件描述符并释放手动分配的内存。

延迟语句将执行延迟到当前范围退出。该语句由defer关键字和稍后执行的语句组成。递延语句可能不包含将控制权从语句中转移出去的任何代码，例如break或return语句，或者通过抛出错误。延迟操作的执行顺序与在源代码中编写它们的顺序相反。也就是说，第一个deferred语句中的代码最后执行，第二个deferred语句中的代码倒数执行，依此类推。源代码顺序中的最后一个deferred语句首先执行。

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.
    }
}

上面的例子使用了一个deferred语句来确保open(:)函数有一个对应的调用来close(:)。

即使不涉及错误处理代码，也可以使用deferred语句。

<<返回目录