指南：错误处理（Error Handling）

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

表示并抛出错误（Representing and Throwing Errors）

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

• Swift 的枚举类型尤为适合构建一组相关的错误状态，枚举的关联值还可以提供错误状态的额外信息。

• 抛出一个错误表明有意外情况发生，导致正常的执行流程无法继续执行。抛出错误使用throw关键字。

处理错误（Handling Errors）

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

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

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

用 throwing 函数传递错误（Propagating Errors Using Throwing Functions）

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

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

用 Do-Catch 处理错误（Handling Errors Using Do-Catch）

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

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

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

• catch子句不必将do子句中的代码所抛出的每一个可能的错误都作处理。如果所有catch子句都未处理错误，错误就会传递到周围的作用域。然而，错误还是必须要被某个周围的作用域处理的——要么是一个外围的do-catch错误处理语句，要么是一个 throwing 函数的内部。

将错误转换成可选值（Converting Errors to Optional Values）

• 可以使用try?通过将错误转换成一个可选值来处理错误。如果在评估try?
  表达式时一个错误被抛出，那么表达式的值就是nil。

• 如果想对所有的错误都采用同样的方式来处理，用try?就可以写出简洁的错误处理代码。

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

禁用错误传递（Disabling Error Propagation）

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

用try? 代替 try!，值可以不用，多写一行if let也没什么，要防止崩溃

enum VendingMachineError: ErrorType {
    case InvalidSelection                    //选择无效
    case InsufficientFunds(coinsNeeded: Int) //金额不足
    case OutOfStock                          //缺货
}

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

        dispenseSnack(name)
    }
}

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

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

var vendingMachine = VendingMachine()
vendingMachine.coinsDeposited = 8
do {
    try buyFavoriteSnack("Alice", vendingMachine: vendingMachine)
} 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.")
}
// 打印 “Insufficient funds. Please insert an additional 2 coins.”

指定清理操作（Specifying Cleanup Actions）

• 可以使用defer语句在即将离开当前代码块时执行一系列语句。该语句让你能执行一些必要的清理工作，不管是以何种方式离开当前代码块的——无论是由于抛出错误而离开，还是由于诸如return或者break的语句。

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

• defer语句将代码的执行延迟到当前的作用域退出之前。该语句由defer关键字和要被延迟执行的语句组成。

• 延迟执行的语句不能包含任何控制转移语句，例如break或是return语句，或是抛出一个错误。

• 延迟执行的操作会按照它们被指定时的顺序的相反顺序执行——也就是说，第一条defer语句中的代码会在第二条defer语句中的代码被执行之后才执行，以此类推。

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

func processFile(filename: String) throws {
    if exists(filename) {
        let file = open(filename)
        defer {
            close(file)
        }
        while let line = try file.readline() {
            // 处理文件。
        }
        // close(file) 会在这里被调用，即作用域的最后。
    }
}
// 使用一条defer语句来确保open(_:)函数有一个相应的对close(_:)函数的调用。

• enum和ErroyType配对使用，推荐。抛出异常，指明错误原因，在网络，文件，数据库等涉及资源相关概念的场景适合使用
• defer关键字，强烈推荐使用。文件打开，马上写上关闭，成对出现。这是一种好的编程习惯。
• guard和throw配对使用，推荐。先检查条件，再往下执行具体任务。
• do - try - catch结构和其他的try-catch-finally结构是不一样的
• try？是一种简化写法，不推荐用。直接用可选类型的普通函数就好了，函数定义时就不要加throw关键字了。
• try！强烈不推荐使用，用try？代替
• Swift整体的错误处理的思路还是值得肯定的。首先，错误处理抛出异常会打断程序的正常执行顺序，所以并不推荐经常使用，所以要加throw、try等关键字，增加使用麻烦度。其次，在真正需要使用抛出异常的地方，位置信息更加精确。最后，将枚举和协议的概念引入，让错误信息的表达更加方便。
• Object-C是使用NSError来处理错误的，没有异常抛出过程，使用时要传地址&，这是C语言常见的错误处理过程。这样的好处是程序的执行流程不会被打断，错误信息可以存储，信息是否使用，由调用者决定。
• 两种错误处理方式各有优缺点，在Swift中，还是推荐Swift特有的错误处理方式，还算是比较好用好理解的。
• 一般情况下，可选类型就足够表达意思了；在需要处理错误信息的场合，才考虑引入错误处理机制。比如文件读写，网络，数据库等等。