概述
错误处理 使你能够在你的程序运行出现错误的时候，处理这个错误并使程序继续向下运行。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 */
