swift之错误处理异常处理

一、错误处理

1.1-错误类型

/*
跟其它语言一样，Swift的异常处理是在程序抛出异常后的处理逻辑。 Swift提供了一流的异常抛出、捕获和处理的能力。跟Java语言类似， Swift的异常并不是真正的程序崩溃， 而是程序运行的一个逻辑分支；Swift和Java捕获异常的时序也是一样的。当Swift运行时抛出异常后并没有被处理， 那么程序就会崩溃。
在Swift语言中使用Error表示异常， 作用同Java的Exception类或Object-C的NSError类。 苹果建议使用枚举作为异常类型（为什么不推荐用类或者结构体？答案是枚举数据类型本身就是分成若干种情况，很适合做逻辑分支判断条件）。

常见错误类型：
1、语法错误（编译报错）
2、逻辑错误（逻辑问题）
3、运行时错误（可能会导致闪退，一般也叫做异常）
如果最外层main没有处理则会导致应用闪退
*/

1.2-自定义错误

/*
Swift中可以通过Error协议自定义运行时的错误信息
函数内部通过throw抛出自定义Error，可能会抛出Error的函数必须加上throws声明
需要使用try调用可能会抛出Error的函数

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

func divide(_ num1: Int, _ num2: Int) throws -> Int {
    if num2 == 0 {
        throw SomeError.illegalArg("0不能作为除数")
    }
    return num1 / num2
}
var result = try divide(20, 10)
var result = try divide(20, 0)
	test[5475:220076] Fatal error: Error raised at top level: test.SomeError.illegalArg("0不能作为除数")

1.3-do catch

/*
可以使用do-catch捕捉Error
抛出Error后，try下一句直到作用域结束的代码都将停止运行
*/
print("1")
do {
    print("2")
    print(try divide(20, 0))
    print("3")
} catch let SomeError.illegalArg(msg) {
    print("参数异常:", msg)
} catch let SomeError.outOfBounds(size, index) {
    print("下标越界:", "size=\(size)", "index=\(index)")
} catch SomeError.outOfMemory {
    print("内存溢出") }
catch {
    print("其他错误") }
print("4")


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

1.4-处理Error

/*
处理Error的2种方式
通过do-catch捕捉Error
不捕捉Error，在当前函数增加throws声明，Error将自动抛给上层函数,如果最顶层函数(main函数)依然没有捕捉Error，那么程序将终止
*/
func test() throws {
    print("1")
    print(try divide(20, 0))
print("2") }
try test()

func test() throws {
    print("1")
    do {
        print("2")
        print(try divide(20, 0))
        print("3")
    } catch let error as SomeError {
        print(error)
    }
    print("4")
}
try test()
1
2
illegalArg("0不能作为除数")
4
do {
    print(try divide(20, 0))
} catch is SomeError{
    print("SomeError")
}
SomeError

1.5-try?try!

/*
剋使用try？try！调用可能会抛出error的函数，这样就不用去处理Error，是option类型
例子中a和b是等价的
*/
func test() {
    print("1")
    var result1 = try? divide(20, 10) // Optional(2), Int?
    var result2 = try? divide(20, 0) // nil
    var result3 = try! divide(20, 10) // 2, Int
    print("2")
}
test()
1
2

1.6-rethrows申明

/*
rethrows表明:函数本身不会抛出错误，但调用闭包参数抛出错误，那么它会将错误向上抛
*/
func exec(_ fn: (Int, Int) throws -> Int, _ num1: Int, _ num2: Int) rethrows {
    print(try fn(num1, num2))
}
try exec(divide, 20, 0)
Fatal error: Error raised at top level:

1.7-defer(finally)

/*
defer语句:用来定义以任何方式(抛错误、return等)离开代码块前必须要执行的代码 
defer语句将延迟至当前作用域结束之前执行
defer语句的执行顺序与定义顺序相反
*/
func open(_ filename: String) -> Int {
    print("open")
    return 0
}

func close(_ file: Int) {
    print("close")
}
func processFile(_ filename: String) throws {
    let file = open(filename)
    defer {
        close(file)
    }
    // 使用file
    // ....
    try divide(20, 0)
}
try processFile("test.txt")
open
close
Fatal error: Error raised at top level:

func fn1() { print("fn1") }
func fn2() { print("fn2") }
func test() {
    defer { fn1() }
    defer { fn2() }
}
test()
fn2
fn1

1.8-assert断言

/*
很多编程语言都有断言机制:不符合指定条件就抛出运行时错误，常用于调试(Debug)阶段的条件判断
默认情况下，Swift的断言只会在Debug模式下生效，Release模式下会忽略
增加Swift Flags修改断言的默认行为
	-assert-config Release:强制关闭断言
	-assert-config Debug:强制开启断言
*/
func divide(_ v1: Int, _ v2: Int) -> Int {
    assert(v2 != 0, "除数不能为0")
    return v1 / v2
}
print(divide(20, 0))

1.9-fatalError

/*
如果遇到严重问题，希望结束程序运行时，可以直接使用fatalError函数抛出错误(这是无法通过do-catch捕捉的错误)
使用了fatalError函数，就不需要再写return
在某些不得不实现、但不希望别人调用的方法，可以考虑内部使用fatalError函数
*/
func test(_ num: Int) -> Int {
    if num >= 0 {
        return 1
        
    }
    fatalError("num不能小于0")
}

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()
Fatal error: don't call Student.init: file

1.10-局部作用域

class Dog{
    var age:Int=0
    func run(){
        print("dog run.")
    }
    init(){}
}
do {
    let dog1 = Dog()
    dog1.age = 10
    dog1.run()
}

do {
    let dog2 = Dog()
    dog2.age = 10
    dog2.run()
}

print(1)
dog run.
dog run.
1