错误处理

表示并抛出错误

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

enum VendingError:Error {
    case invalidSelection                     // 选择无效
    case insufficientFunds(coinsNeeded: Int)  // 金额不足
    case outOfStock                           // 缺货
}

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

throw VendingError.insufficientFunds(coinsNeeded: 2)

处理错误

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

throwing 函数传递错误

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

class VendingMachine {
    var price = 5
    var count = 10
    func vend(coins: Int) throws {
        // 投入的金额不足抛出错误 金额不足
        guard coins >= price else {
            throw VendingError.insufficientFunds(coinsNeeded: price-coins)
        }
        // 剩余量不足时抛出错误 缺货
        guard count - coins / price > 0 else {
            throw VendingError.outOfStock
        }
        count = count - num;
    }
}

Do-Catch 处理错误

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

let machine = VendingMachine()
do {
    try machine.vend(coins: 3)
}
catch VendingError.outOfStock {
    print("货品不足")
}
catch VendingError.insufficientFunds(let coinsNeeded) {
    print("还需要投入\(coinsNeeded)个硬币")
}
// 打印 还需要投入3个硬币

将错误转换成可选值

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

enum SumError: Error {
    case arrayIsEmpty
}

func getSum(numbers: Array<Int>) throws -> Int {
    if numbers.count == 0 {
        throw SumError.arrayIsEmpty
    }
    else {
        var sum = 0
        for num in numbers {
            sum += num
        }
        return sum
    }
}

let sum = try? getSum(numbers: [])
if let x = sum {
    print(x)
} else {
    print("数组为空")
}

禁用错误传递

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

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

指定清理操作

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

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(_:)函数的调用。

---

类型转换

检查类型

用类型检查操作符is来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回true，否则返回false。

class Animal {
   
}
class Dog: Animal {
    var name: String
    init(name: String) {
        self.name = name
    }
}
class Cat: Animal {
    var name: String
    init(name: String) {
        self.name = name
    }
}

let someDog = Dog(name: "旺财")
let someCat = Cat(name: "Kitty")

var animals: [Animal] = [someDog, someCat]

for animal in animals {
    print(animal is Dog)
}
// true
// false

当实例的类型不确定，可以用类型检查来判断类型。如果能够确定类型那么这个判断就是多余的：

let ret = someDog is Dog  // 'is' test is always true

向下转型

因为向下转型可能会失败，类型转型操作符带有两种不同形式。条件形式as?返回一个你试图向下转成的类型的可选值。强制形式as!把试图向下转型和强制解包转换结果结合为一个操作。

当你不确定向下转型可以成功时，用类型转换的条件形式as?。条件形式的类型转换总是返回一个可选值，并且若下转是不可能的，可选值将是nil。这使你能够检查向下转型是否成功。

只有你可以确定向下转型一定会成功时，才使用强制形式as!。当你试图向下转型为一个不正确的类型时，强制形式的类型转换会触发一个运行时错误。

for animal in animals {
    if let cat = animal as? Cat {
        print(cat.name)
    }
}
// Kitty

Any 和 AnyObject 的类型转换

Swift为不确定类型提供了两种特殊的类型别名：

• Any 可以表示任何类型，包括函数类型。
• AnyObject 可以表示任何类类型的实例。

var things: [Any] = [1, 2.5, "hello", (3, 5.0), someDog, someCat]

for thing in things {
    switch thing {
    case let someInt as Int:
        print("\(someInt) is Int")
    case let someDouble as Double:
        print("\(someDouble) is Double")
    case let someString as String:
        print("\(someString) is String")
    case let (x, y) as (Int, Double):
        print("\(x) is Int, \(y) is Double")
    case let someDog as Dog:
        print("Dog is \(someDog.name)")
    case let someCat as Cat:
        print("Cat is \(someCat)")
    default:
        print("other")
    }
}
// 1 is Int
// 2.5 is Double
// hello is String
// 3 is Int, 5.0 is Double
// Dog is 旺财
// Cat is Kitty