Swift中错误处理机制很丰富,也比较容易掌握,今天就来学习一下swift中的常用错误处理方式.

1. assert

基本格式: assert(条件),并且assert只在debug模式下有效, 在realease环境下无效,这样我们就不用担心上架后因此引起的崩溃.

assert(<#T##condition: Bool##Bool#>)

对于assert,大家都不陌生,当条件不成立时,会立即中断程序的运行, 并定位到出错的代码,控制台打印相应的信息:

assert还有一个可以自定义控制台输出信息的方法:

assert(<#T##condition: Bool##Bool#>, <#T##message: String##String#>)

使用是这样的:

assert还有一个无条件停止程序运行的方法,不需要任何条件,程序执行到这句就报错:

无条件报错

上面这几个,全部是在debug模式下有效, 当调整到realease环境,就无效,所以在开发中可以大胆使用这些来调试程序中可能出现的错误.

2. precondition

precondition的用法和作用与assert相同,唯一的区别是: assert在realease环境下就无效了, 而precondition在realease环境下依然可以执行; 如果在用户使用过程中发生了某种异常,需要强制退出APP,可以在适当的地方添加precondition;

基本用法 带有错误信息 无条件报错

3. 错误处理

举一个猜大小的例子吧:

class Guess {
    
    var count = 4
    func enterNumber(_ num: Int) -> Bool {
        
        if num < count {
            
            return false
        } else if num > count {
            
            return false
        } else if num == count {
            
            return true
        }
        return false
    }
}

3.1 Error

如果我们能够知道我们的方法或者类会抛出哪些异常,我们可以定义一个枚举,来列举这些错误,然后再分情况去处理,比如,我们定义一个猜数字的错误类型: 要么大,要么小,可以这样定义:

enum MyError: Error {
        
        case big
        case small
    }

这个枚举的定义可以放在类的外面,单独定义,也可以嵌套在类中定义,这里只是在类中访问这个错误信息,所以定义在了类里面,即:

class Guess {
    
    var count = 4
    enum MyError: Error {
        
        case big
        case small
    }
    
    func enterNumber(_ num: Int) -> Bool {
        
        if num < count {
            
            return false
        } else if num > count {
            
            return false
        } else if num == count {
            
            return true
        }
        return false
    }
}

3.2 throw

定义好了错误类型, 在可能出错的方法里就要抛出异常,这就用到了throw关键字,在需要抛出异常的地方添加throw关键字, 方法的返回值前要使用throws关键字:

func enterNumber(_ num: Int) throws -> Bool {
        
        if num < count {
            throw MyError.small
           // return false
        } else if num > count {
            throw MyError.big
            //return false
        } else if num == count {
            
            return true
        }
        return false
    }

因为抛出异常后,后面的代码就不会执行,所以这里的return就可以省略不写了.
我们使用枚举来定义了错误类型, 就可以使用枚举的特性: 设置关联值;例如: 在输入的数字过大的时候, 输出输入的数字,可以将枚举修改如下:

enum MyError: Error {
        
        case big(Int)
        case small
    }

然后,方法修改如下:

func enterNumber(_ num: Int) throws -> Bool {
        
        if num < count {
            throw MyError.small
            //return false
        } else if num > count {
            throw MyError.big(num)
            //return false
        } else if num == count {
            
            return true
        }
        return false
    }

当猜的大的时候, 就抛出异常, 并将猜的数组返回.

3.3 try

调用可能抛出异常的函数时,就不能按原先的方式了,

我们需要处理异常,这就用到了try关键字;他有三个用法: try, try!, try?
try: 忽略异常

let gus = Guess()

try gus.enterNumber(3)

try!: 强制处理异常, 当我们坚信不会出异常,就可以使用try!,和可选型的强制解包一样,这也是有风险的:

let gus = Guess()

try! gus.enterNumber(4)

一旦有异常(赋的值不是4的时候), 这样还是会报错的;
try? : 当无异常时,程序正常执行,正常返回数据, 当抛出异常时, 直接返回nil

let gus = Guess()

try? gus.enterNumber(3)

正常 抛出异常,返回nil

这时,我们可以使用if-let简单的处理异常:

let gus = Guess()

if let result = try? gus.enterNumber(4) {
    
    // 正常的处理逻辑
} else {
    
    // 抛出异常的处理逻辑
}

3.4 do-catch

如果我们想要分错误情况去处理异常,这就用到了do-catch:

do {
    try <#throwing expression#>
} catch <#pattern#> {
    <#statements#>
}

do后面可以执行任意多行代码, 无论哪行出错,都可以在catch中捕获这个错误;

do {
    let result = try gus.enterNumber(3)
    
    print(result)
} catch {
    // 错误处理
}

上面我们定义了错误的类型, 这里我们可以根据这些错误类型来分别处理:

do {
    let result = try gus.enterNumber(3)
    
    print(result)
} catch Guess.MyError.small{
    // 处理异常
} catch Guess.MyError.big {
    // 处理异常
} catch {
    // 处理其他异常
}

另外,这里的big设置了一个关联值, 这里可以在捕获的异常里获取到这个值的:

do {
    let result = try gus.enterNumber(3)
    
    print(result)
} catch Guess.MyError.small{
    // 处理异常
} catch Guess.MyError.big(let num) {
    // 处理异常
    print(num)
} catch {
    // 处理其他异常
}

如果错误类型比较多,一个个罗列不是很方便,可以这样写:

do {
    let result = try gus.enterNumber(3)
    
    print(result)
} catch let error {
    
    print(error)
}

这里,如果你知道是上面我们定义的MyError类型的异常,可以转换为MyError:

do {
    let result = try gus.enterNumber(3)
    
    print(result)
} catch let error as Guess.MyError {
    
    print(error)
}

对上面的Error枚举,我们可以添加相应的错误描述,需要遵循CustomStringConvertible协议,并实现description, 完整修改如下:

enum MyError: Error, CustomStringConvertible {
        
        case big(Int)
        case small
        
        var description: String {
            
            switch self {
            case .big(let num):
                
                return "too big \(num)"
                
            case .small:
                return "too small"
            }
        }
    }

这样,在错误处理时,就可以直接输出我们定义的错误信息:

输出错误描述

如果还想捕获,定义的错误类型之外的异常,可以多加一个catch:

do {
    let result = try gus.enterNumber(3)
    
    print(result)
} catch let error as Guess.MyError {
    
    print(error)
} catch {
    
    print("other error")
}

3.5 defer

在我们定义的函数中, 抛出异常之后就会终止程序运行, 如果我们想在程序终止的方法里,做一些后续的操作, 这就用到了defer关键字.
defer, 就是延迟执行的意思, 当程序跳出当前的作用域的时候就会执行这里面的逻辑, 无论是抛出异常跳出的还是正常跳出的.
我们可以把Guess里的方法做如下修改:

func enterNumber(_ num: Int) throws -> Bool {
        
        defer {
            print("game over")
        }
        
        if num < count {
            throw MyError.small
            //return false
        } else if num > count {
            throw MyError.big(num)
            //return false
        } else if num == count {
            
            return true
        }
        return false
    }

一个方法里可以加入多个defer,执行的顺序是倒叙的,就是前面的defer后执行.

4. Never

如下所示, 在使用guard函数进行判断的时候: 如果出错则中断程序的运行;

func mod(_ a: Int, _ b: Int) -> Int {
    guard b != 0 else {
        fatalError()
    }
    
    return a % b
}

如果在else中使用了自定义的函数:

Never

在逻辑上, 和上面的写法没什么区别, 但是这样会报错, 因为guard 的else需要一个返回值, 而我们写的函数是没有返回值的, 这时候我们可以将返回值设为Never类型, 这个类型的意思是他有返回值, 但是在正常情况下是不会返回的; 这样就不会再报上面的错误了:

Never

以上就是学习swift中错误处理的总结, 好记性不如烂笔头, 记录一下,以备不时之需查阅...

(完)