小码哥Swift技术学习(day08-错误处理）

一、错误类型

1.开发中常见的错误类型

语法错误（编译错误）

逻辑错误

运行时错误（可能会导致闪退，一般也叫做异常）

......

二、自定义错误类型

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

struct MyError: Error {
    var msg: String
}

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

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

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

var result = try divide(10, 0)
print(result)

4.如果没有对错误处理的话，那么程序就会崩溃，然后抛出错误

struct MyError: Error {
    var msg: String
}

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

var result = try divide(10, 0)
print(result)

三、do-catch

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
}



func test() {
    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")
}

test()

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

四、处理Error

1.处理Error的2种方式

1）通过do-catch捕捉Error

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

3）如果最顶层函数（main函数）依然没有捕捉Error,那么程序将终止

func test() throws {
    print("1")
    print(try divide(20, 0))
    print("2")
}

try test()

4）将error转换成自定义的错误

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

5）无论是什么类型的错误，只有抛出异常，就捕捉

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

五、try?、try!

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

func test1() {
    print("1")
    let result1 = try? divide(20, 10)
    print("result1的值为:\(result1)")
    let result2 = try? divide(20, 0)
    print("result2的值为:\(result2)")
    let result3 = try! divide(20, 10)
    print("result3的值为:\(result3)")
    print("2")
}

test1()

// a、b是等价的
var a = try? divide(20, 0)
var b: Int?
do {
    b = try divide(20, 0)
} catch {
    b = nil
}

六、rethrows

1.rethrows表明：函数本身不会抛出异常，但调用闭包参数抛出错误，那么它会将错误向上抛

// rethrows
func exec(_ fn: (Int, Int) throws -> Int, _ num1: Int, _ num2: Int) rethrows {
    print(try fn(num1, num2))
}

try exec(divide, 20, 0)

七、defer

1.defer语句：用来定义以任何方式（抛错误、return等）离开代码块前必须要执行的代码

2.defer语句将延迟至当前作用域结束之前执行

func test2() throws {
    print("1")
    try test3()
    print("2")
}

func test3() throws {
    print("3")
    try test4()
    print("4")
}

func test4() throws {
    print("5")
    print(try divide(200, 0))
    print("6")
}

try test2()

​​​​​​​

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
    print("处理文件")
    try divide(20,0)
    print("处理文件结束")
//    defer {
//        close(file)
//    }
}

try processFile("test.txt")

defer必须写在可能会抛出错误或者是return的前面，不然return或者抛出错误以后代码就不在执行，但是这个defer包裹的代码又会在程序作用域结束之前执行

八、assert（断言）

1.很多编程语言都有断言机制：不符合指定条件就抛出运行时错误，常用于调试（Debug）阶段的条件判断

2.默认情况下，Swift的断言只会在Debug模式下生效，Release模式下会忽略

3.使用

func divide1(_ v1: Int, _ v2: Int) -> Int {
    assert(v2 != 0, "除数不能为0")
    return v1 / v2
}
print(divide1(20, 0))

执行顺序是条件如果成立，那么就继续往下执行，如果条件不成立，那么就抛出异常，崩溃

4. 增加Swift Flags修改断言的默认行为

默认情况下是assert只会在debug下执行，如果在release模式下的话那么就会直接崩溃，不会进行详细错误的展示，下面是release模式下的效果，不会提示详细错误

1.如果想在release模式下，强制开启断言的话执行

-assert-config Debug