The Swift Programming Language 翻译 —— 错误处理

概述

错误处理 使你能够在你的程序运行出现错误的时候，处理这个错误并使程序继续向下运行。Swift支持抛出（throwing）、捕获（catching）、传递（propagating）和操作（manipulating）等四种方式来处理程序运行时出现的可恢复性错误。

某些操作并不是总能够执行完毕或者输出一个有效的值。可选类型可以用来处理没有输出有效值的情况，但是当某些操作失败的时候，找到失败的原因同样对我们大有帮助，这样我们就可以针对各种原因做出不同的应对。

比如我们在执行一个读取磁盘文件并处理其数据的任务，有很多种原因可以导致任务失败：文件不存在，没有读取权限或者文件格式不兼容等等。区分这些错误能够让我们的程序处理不同的情况，比如解决某些可以解决的错误，然后告知用户那些不能被解决的错误。

注意：Swift中的错误处理和 Cocoa 和 OC 中的 NSError 这种错误处理模式是一致的。在 Cocoa 中，可能出现错误的方法都有一个（NSError **）类型的参数作为他们的最后一个参数。当你在 Swift 中调用这些方法时，Swift 自动将这些方法翻译为可以抛出错误的方法。

比如 NSFileManager 中的这个方法

- (BOOL) removeItemAtURL:(NSURL *)URL error:(NSError **)error

在 Swift 中会被转化为 

func removeItemAtURL(URL: NSURL) throws

关于这点的详细信息请查阅 Using Swift With Cocoa and Objective-C 一书。

表示错误类型

在 Swift 中，错误类型用继承了 ErrorType 协议的类型来表示。ErrorType 协议是一个空协议，仅表明某个类型可以用来表示错误的种类（注：我们可以根据上下文自定义错误的类型，从而分别处理）。

Swift 中的枚举类型非常适合于表示一组相关的错误情形，尤其是枚举值可以拥有相关值这个特性，使我们能够获得其所表示的错误情形的更多信息。比如，我们要表示在游戏中操作自动贩卖机（ Vending Machine）时可能出现的错误情形时，可以定义如下的枚举：

enum VendingMachineError: ErrorType {
    case InvalidSelection \\ 选择无效
    case InsufficientFunds(coinsNeeded: Int) \\ 余额不足，Int型相关值表示差额
    case OutOfStock \\ 缺货
}

抛出错误

当程序运行发生错误，导致正常流程无法继续执行的时候，你可以使用 throw 关键字来抛出这个错误。如下代码抛出了一个余额不足的错误，并且差额为5：

throw VendingMachineError.InsufficientFunds(coinsNeeded: 5)

处理错误

一个抛出的错误必须被其上下文中的代码处理掉，可以纠正这个错误，也可以尝试另一种方法，或者直接将这个错误通知给用户。

Swift 中处理错误的方式有如下四种：使用 throw 关键字继续向上传递这个错误、使用 do-catch 表达式处理这个错误、使用 try? 关键字将该错误当做可选类型来处理、使用 try！关键字来表明这种类型的错误无需处理。下面将一一演示这四种方式。

在可能出现错误的代码之前加上 try（或者 try?、try!）关键字来表明此代码有出错潜质。

注意：Swift 中的错误处理和其他语言中的异常处理相似，都使用了 try，catch，throw 这些关键字。但是和其他许多语言（包括OC）中的异常处理不同的是，Swift中的错误处理不会获取调用栈的信息（获取调用栈信息可能会非常消耗资源）。正因如此，Swift中 throw 表达式的性能和 return 表达式相差无几。

1. 使用可抛出函数(throwing functions)传递错误

为了表明一个函数、方法或者构造器可以抛出错误，你可以在函数声明中的参数列表之前使用 throws 关键字，这样的函数被称为可抛出函数（throwing functions）。如果一个函数带有返回值，throws 关键字应该写在返回值的箭头之前：

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 dispenseSnack(snack: String) {
        print("Dispensing \(snack)")
    }

    // 购买商品
    func vend(itemNamed name: String) throws {
        // 根据商品名称获取商品信息。如果商品不存在，则抛出选择无效错误。
        guard var 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
        --item.count
        inventory[name] = item
        dispenseSnack(name)
    }
}

在 vend(itemNamed: Stirng) 方法中，只有三个条件完全满足才可以完成购买。任一条件不满足时，都会抛出对应类型的错误，提前结束方法的执行并将错误传递给方法的调用者，由其负责处理。

guard关键字是Swift 2.0中加入的新特性，很适合用来判断是否需要提前结束方法，详细信息请自行查阅资料。

vend(itemNamed: String) 方法将错误向上传递给了他的调用者，他的调用者可以继续向上传递，也可以使用 do-catch、try? 或者 try! 语句将错误处理掉。向上传递错误的话，方法所在的整条调用链中，必须有某个函数将错误处理掉。下面例子中的 buyFavoriteSnack(_:vendingMachine:) 方法调用了 vend(itemNamed: String) 方法，任何 vend(itemNamed: String) 方法抛出的错误都将传递给他，他选择继续向上传递这些错误。

// 记录某些人和他们最爱吃的零食
let favoriteSnacks = [
    "Alice": "Chips","Bob": "Licorice","Eve": "Pretzels"
]

// 到某个自动贩卖机中购买某人最爱吃的零食
func buyFavoriteSnack(person: String,vendingMachine: VendingMachine) throws {
    // 使用空合运算符给 snackName 赋值。
    let snackName = favoriteSnacks[person] ?? "Candy Bar"
    // 调用自动贩卖机中的 vend(itemNamed: String) 方法购买零食。
    try vendingMachine.vend(itemNamed: snackName)
}

注意：
 1. 空合运算符：如果其前面的可选值为nil，就使用后面的默认值给变量赋值；如果不为nil，使用可选值解析后的值给变量赋值。
 2. 调用可抛出方法时，应该在其前使用 try、try? 或者 try! 表明该语句可能抛出错误。

2. 使用 do-catch 处理错误

你可以使用 do-catch 表达式来处理错误。do-catch 表达式的使用格式如下所示：

do {
    // 将可能抛出错误的语句放在 do 后面的大括号中。
    try expression
    // 如果 expression 没有抛出错误，statements1 正常执行；如果抛出了错误，statements1 不会被执行，而是跳出 do 代码块去寻找与所抛出的错误相匹配的 catch 语句，由其来处理错误。
    statements1
} catch pattern1 {
    // 此 catch 语句捕获与 pattern1 相匹配的错误，并处理
    statements2
} catch pattern2 where condition {
    // 此 catch 语句捕获与 pattern2 相匹配并满足条件 condition 的错误，并处理
    statements3
} catch {
    // 此 catch 语句没有指定其要匹配的 pattern，所有没有被上面的 catch 语句所匹配的错误都会交由该 catch 语句处理。
    statements4
}

当一个 catch 语句没有指定其要匹配的 pattern 的时候，任何错误都会被其捕获，并且系统会将捕获到的错误绑定到一个叫做 error 的常量上。当 catch 语句指定了与其匹配的错误的时候，系统不会自动绑定 error 常量。

do-catch 语句中的 catch 语句不是必须能够捕获全部可能抛出的错误。如果某些错误没有 catch 语句来捕获他，系统会将该错误向上传递。下面的例子中，do-catch 语句处理所有 VendingMachineError 中的三种错误类型，但是如果抛出其他类型的话，则会被向上传递。

var vendingMachine = VendingMachine()
vendingMachine.coinsDeposited = 8
do {
    try buyFavoriteSnack("Alice",vendingMachine: vendingMachine)
} catch VendingMachineError.InvalidSelection {
    print("Invalid Selection.")
} catch VendingMachineError.OutOfStock {
    print("OutOfStock.")
} catch VendingMachineError.InsufficientFunds(let coinsNeeded) {
    print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.")
}

// 执行结果：Insufficient funds. Please insert an additional 2 coins.

下面的例子验证一下当 catch 语句没有指定要匹配的错误时，本地 error 常量的使用。

// 先在 VendingMachineError 中添加一个只读的计算型属性 description。
enum VendingMachineError: ErrorType {
    var description: String {
        switch self {
        case .InvalidSelection:
            print("InvalidSelection")
        case .OutOfStock:
            print("OutOfStock")
        case .InsufficientFunds(let coinsNeeded):
            print("InsufficientFunds with \(coinsNeeded) more coins needed")
        }
    }

    case InvalidSelection \\ 选择无效
    case InsufficientFunds(coinsNeeded: Int) \\ 余额不足，Int型相关值表示差额
    case OutOfStock \\ 缺货   
}

let vendingMachine = VendingMachine()
do {
    try vendingMachine.vend(itemNamed: "Chips")
} catch {
    // 验证 error 是否为 VendingMachineError 类型
    if (error as? VendingMachineError) != nil {
        // 验证成功，输出 error 的 description 属性。此时需要强制类型转换。
        print((error as! VendingMachineError).description)
    } else {
        // 验证失败，输出信息
        print("not a VendingMachineError")
    }
}

// 输出结果： InsufficientFunds with 10 more coins needed

如果可抛出方法中有可能抛出多种类型的错误时（比如 vend(itemName: String) 方法还有可能抛出其他非 VendingMachineError 类型的错误时），可以在未指定匹配类型的 catch 语句后面直接判断错误类型并进行绑定，如下例：

let vendingMachine = VendingMachine()
do {
    try vendingMachine.vend(itemNamed: "Chips")
} catch let unknownTypeError as? VendingMachineError {
    // 验证成功，并已完成类型转换
    print(unknownTypeError.description)
}

// 输出结果： InsufficientFunds with 10 more coins needed

3. 将错误转化为可选类型来处理

你可以使用 try? 表达式将一个可抛出方法的调用转化为可选类型来处理，此时不需要将方法调用语句放在 do-catch 内部。如果可抛出方法在执行过程中，抛出了错误，则整个 try? 表达式的值为 nil。下面代码中x 和 y 的值都为 nil。

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

// try? 表达式返回可选类型值。如果 someThrowingFunction() 抛出了错误，try?表达式的值为 nil，否则表达式的值为 someThrowingFunction() 的返回值。因此 x 的类型为 Int?。
let x = try? someThrowingFunction()

// 声明 y 为 Int? 类型，使用 do-catch 处理错误，并根据情况给 y 赋值。
let y: Int?
do {
    // 如果执行过程中没有抛出错误，y 的值为 someThrowingFunction() 的返回值。
    y = try someThrowingFunction()
} catch {
    // 有错误被抛出，将 y 设为 nil。
    y = nil
}

以上代码中，x 和 y 的赋值过程完全等价。由于 someThrowingFunction() 的返回值类型是 Int，所以 x 和 y 的类型都为 Int?。x 和 y 的类型是 someThrowingFunction() 的返回值类型对应的可选类型。

如果某个可抛出方法没有返回值，也可以使用 try? 将其转化成可选值处理，当然，此时不能将 try? 表达式的值赋给某个常量或者变量。如上面代码中的 buyFavoriteSnack(person:,vendingMachine:) 方法，他是一个可抛出方法，他没有返回值，可以如下使用 try? 处理他的调用：

let vendingMachine = VendingMachine()
try? buyFavoriteSnack("Alice",vendingMachine: vendingMachine)

当你希望使用相同的方式处理所有类型的错误时，使用 try? 表达式可以使你的代码非常简洁。下面代码中的 fetchData() 方法使用不同的方式来获取数据，当所有方式都未能成功时，返回nil，否则返回获取到的数据。

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

4. 将错误标示为无需处理

有些时候当你调用一个可抛出方法时，你确定他在执行过程中不会抛出错误，此时你可以在调用语句之前使用 try! 关键字。使用 try! 关键字相当于告诉系统这个语句调用不会抛出错误的，无需处理。但是，如果他没有如你所想，抛出了错误，你将会得到一个运行时错误。

下面的代码调用 loadImage(_:) 方法加载给定路径的图片，如果图片不存在，就抛出一个错误。因为图片一般都是和应用程序一起打包过来的，所以基本肯定不会抛出错误。此时可以使用 try! 关键字。

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

释放资源

defer 关键字使得你可以在一个代码块即将执行完成之前执行一组操作（关闭文件、释放内存或者仅仅是打出一些log），不论这个代码块是因为 break、return、throw 还是其他方式而即将执行完成。

defer 所执行的操作中，最好不要包含能够改变程序执行流程的语句，如 break、return 或者 throw。一个代码块中可以包含多个 defer 操作，这些 defer 操作将以与定义顺序相反的顺序被执行。

不论代码块中是否包含错误处理，你都可以使用 defer 关键字。

func processFile(filename: String) throws {
    if exists(filename) {
        let file = open(filename)
        // 使用 defer 关键字执行关闭文件的操作，确保方法执行完毕之前，文件会被关闭。 
        defer {
            close(file)
        }
        while let line = try file.readline() {
            // work with the file.
        }

        // defer 语句中关闭文件的操作将会在此时被执行，代码块即将执行完成之际。
    }
}

func deferTest() {
    defer {
        print("00000")
    }

    defer {
        print("11111")
    }

    print("22222")
}

deferTest()

/* 执行结果:22222 11111 00000 */