Swift --- 错误处理（Error）：throws、断言assert、fatalError

• Swift中可以通过Error协议自定义运行时的错误信息

enum SomeError : Error {
    case illegalArg(String)
    case outOfBounds(Int, Int)
    case outOfMemory
}

• 函数内部通过throw抛出自定义Error，可能会抛出Error的函数必须加上throws声明

func divide(_ num1: Int, _ num2: Int) throws -> Int {
    if num2 == 0 {
        throw SomeError.illegalArg("0不能作为除数")
    }
    return num1 / num2
}

• 需要使用try调用可能会抛出Error的函数

var result = try divide(10, 0)    // 能编译通过，向上抛出错误

处理Error的两种方式：

1. 可以使用do-catch捕捉Error

• 抛出Error后，try下一句直到作用域结束的代码都将停止运行

func test() {
    print("1")
    do {
        print("2")
        print(try divide(20, 0))
        print("3")                                      //不会只执行
    } catch let SomeError.illegalAr(msg) {
        print("参数异常:", msg)
    } catch let SomeError.outOfBouds(size, index) {
        print("下标越界:","size=\(size)","index=\(index)")
    } catch SomeError.outOfMemory {
        print("内存溢出")
   } catch {
       print("其他出错")
   }
   print("4")
}
test()  //1 2 参数异常:0不能作为除数 4

2. 不捕捉Error，在当前函数增加throws声明，Error将自动抛给上层函数

• 如果最顶层函数(main函数)依然没有捕捉Error，那么程序将终止

func test() throws {
    print("1")
    print(try divide(20, 0))
    print("2")          //不会执行
}
try test()
//1
// Fatal error: Error raised at top level

不同写法：

do {
    print(try divide(20, 0))
} catch is SomeError {
    print("SomeError")
} catch {
    print("Others")
}

do {
    print(try divide(20, 0))
} catch let error {  
    switch error {
    case let SomeError.illeaglArg(msg):
        print("参数错误:", msg)
    default
        print("其他错误")
    }
}

• 如果能在当前方法中能处理错误，执行do-catch后面的代码，不能处理错误的话往上抛，则不执行

func test() throws {
    print("1")
    do {
        print("2")   
        print(try divide(20, 0))
        print("3")   //不会执行
    } catch let error as SomeError {   // 转换不成功，向上抛出
        print(error)
    }
    print("4")      //如果能在当前方法中能处理错误，执行do-catch后面的代码，不能处理错误的话往上抛，则不执行
}
try test()
// 1
// 2
// illegalArg("0不能作为除数")
// 4       

---

关键字：try?、try!

• 可以用try?、try!调用可能会抛出Error的函数，这样就不用去处理Error

func test() {
    print("1")
    var result1 = try? divide(20, 10)  //Optional(2), Int?
    var result2 = try? divide(20, 10)  //nil
    var result3 = try! divide(20, 10)  //2, Int
    print("2")
}
test()

• a、b等价

var a = try? divide(20, 0)
var b: Int?
do {
    b = try divide(20, 0)   //抛出错误，不会赋值
} catch {
    b = nil
}

关键字：rethrows

• rethrows声明：函数本身不会抛出错误，但调用闭包参数抛出错误，那么它会将错误向上抛

func exec(_ fn: (Int, Int) throws -> Int, _ num1: Int, _ num2: Int) rethrows {
    print(try fn(num1, num2))
}
// Fatal error: Error raised at top level
try exec(divide, 20, 0)

关键字：defer

• defer语句：用来定义任何方式（抛错误、return等）离开代码块前必须要执行的代码
• defer语句延迟至当前作用于结束之前执行
• defer语句的执行顺序与定义顺序相反

---

assert（断言）

---

fatalError

• 如果遇到严重问题，希望结束程序运行时，可以直接使用fatalError函数抛出错误（这是无法通过do-catch捕捉的错误）
• 使用了fatalError函数，就不需要再写return

func test(_ num: Int) -> Int {
    if num >= 0 {
        return 1
    }
    fatalError("num不能小于0")
}

• 在某些不得不实现、但不希望别人调用的方法，可以考虑内部使用fatalError函数

class Person { required init(){} }
class Student : Person {
   required init() { fatalError("don't call Student.init") }
   init(score: Int) {}
}
var stu1 = Student(score: 98)
var stu2 = Student()