Swift中的异常和错误处理—— 异常处理基础篇

Swift中的异常和错误处理

泊学原文

只要咱们在编程，就必定要面对错误处理的问题。其实，为了让咱们少犯错误，Swift在设计的时候就尽量让咱们明确感知错误，明确处理错误。例如：

• 只有使用Optional才能处理空值；

• switch...case...必须处理全部的请求；

总之，你到处能感觉到Swift为你少犯错的良苦用心。因此，当你真的要处理错误的时候，Swift固然更会要求你严谨处理。

如何描述一个错误？

在Swift里，任何一个听从ErrorType protocol的类型，均可以用于描述错误。ErrorType是一个空的protocol，它惟一的功能，就是告诉Swift编译器，某个类型用来表示一个错误。而一般，咱们使用一个enum来定义各类错误。例如，假设咱们有一个机器人类型，咱们要定一个表达它工做状态的错误：

enum RobotError: ErrorType {
    case LowPower(Double)
    case Overload(Double)
}

其中LowPower表示电量低，它的associated value表示电量的百分比。而Overload表示超过负载，它的associated value表示最大负载值。

如何描述一个会发生错误的方法？

而后，咱们来建立一个表示机器人的类：

class Robot {
    var power = 1.0
    let maxLifting = 100.0 // Kg
}

它有两个属性，power表示当前电量，maxLifting表示它能够举起来的最大质量。而后，咱们添加一些能够发送给Robot的命令：

enum Command {
    case PowerUp
    case Lifting(Double)
    case Shutdown
}

Command中的三个case分别表示对Robot发送：启动、举重和关机三个命令。

接下来，咱们给Robot添加一个接受命令的方法 action。

class Robot {
    var power = 1.0
    let maxLifting = 100.0 // Kg

    func action(command: Command) throws { }
}

因为action有可能发生异常，对于这样的方法，咱们要明确使用throws关键字标记它。在action的实现里，咱们用一个switch...case来遍历Command：

class Robot {
    var power = 1.0
    let maxLifting = 100.0 // Kg
    
    func action(command: Command) throws {
        switch command {
        case .PowerUp:
            guard self.power > 0.2 else {
                throw RobotError.LowPower(0.2)
            }
            
            print("Robot started")
        case let .Lifting(weight):
            guard weight <= maxLifting else {
                throw RobotError.Overload(maxLifting)
            }
            
            print("Lifting weight: \(weight) KG")
        case .Shutdown:
            print("Robot shuting down...")
        }
    }
}

在action的实现里，当处理.PowerUp命令时，咱们使用了guard确保Robot电量要大于20%，不然，咱们使用throw RobotError.LowPower(0.2)的方式抛出了一个异常（throw出来的类型必须是ErrorType）。

处理.Lifting命令时，咱们读取了.Liftting的associated value，若是要举起的质量大于maxLifting，则throw RobotError.Overload(maxLifting)。

一般，guard和throw配合在一块儿，可让咱们的代码变的更加简洁。

如何处理错误？

当咱们调用了一个可能会抛出异常的方法时，咱们必定要"经过某种方式"处理可能会发生的异常，若是你不处理，iOS会替你处理。固然，做为"代劳"的成本，iOS也会Kill掉你的app。所以，对于"业务逻辑类"的异常，咱们仍是本身处理好些，Swift容许咱们使用三种方式处理异常。为了演示它们的用法，咱们先来定义一个让Robot工做的函数，因为它会调用action，所以它也会抛出RobotError异常，咱们也须要用throws来定义它：

func working(robot: Robot) throws {
}

do...catch...

在working的实现里，首先，咱们要让Robot"启动"：

func working(robot: Robot) throws {
    do {
        try robot.action(Command.PowerUp)
    }
    catch let RobotError.LowPower(percentage) {
        print("Low power: \(percentage)")
    }
}

经过前面action的代码咱们知道，若是传入的robot参数的"电量"低于20%，action会抛出异常，所以在working的实现里：

• 咱们必须在调用会抛出异常的方法前面使用try关键字；

• 若是咱们要捕获方法抛出的异常，就须要把会抛出异常的代码放在关键字do包含的代码块里；

• 咱们使用catch关键字匹配要捕捉的各类异常，例如在上面的例子里，咱们捕捉了.LowPower，而且读取了它的associated value；

若是咱们要捕获多个异常，就能够在do代码块后面，串联多个catch，例如，咱们添加一个让Robot举起某个东西的命令：

func working(robot: Robot) throws {
    do {
        try robot.action(Command.PowerUp)
        try robot.action(Command.Lifting(52))
    }
    catch let RobotError.LowPower(percentage) {
        print("Low power: \(percentage)")
    }
    catch let RobotError.Overload(maxWeight) {
        print("Overloading, max \(maxWeight) KG is allowd")
    }
}

咱们就须要在do后面多串联一个catch，用来捕获Robot"超载"的异常。

错、不错都会执行的代码

在Swift的异常处理机制理，有一个容许咱们添加不管代码执行正常与否，只要离开当前做用域，就必定会执行的代码。咱们使用defer关键字来指定这样的代码。例如，咱们给working添加一个defer，它用来让Robot关机。

func working(robot: Robot) throws {
    defer {
        try! robot.action(Command.Shutdown)
    }

    do {
        try robot.action(Command.PowerUp)
        try robot.action(Command.Lifting(52))
    }
    catch let RobotError.LowPower(percentage) {
        print("Low power: \(percentage)")
    }
    catch let RobotError.Overload(maxWeight) {
        print("Overloading, max \(maxWeight) KG is allowd")
    }
}

断言确定不会错哒～

在上面的defer代码块里，咱们使用了"try!"这样的形式。这是因为defer代码块中，不容许咱们包含任何会跳出当前代码块的语句，例如：break ／ return / 抛出异常等。所以，咱们使用try!告诉Swift咱们肯定这个调用不会发生异常（若是你对Swift说谎，是会引起运行时异常的 ^.^）。

另外，使用"try!"标记的函数调用，能够不放在do代码块里。

把错误变成一个Optional

最后，咱们调用working函数，让Robot完成工做：

let iRobot = Robot()
try? working(iRobot)

在这里，咱们咱们使用了"try?"的形式调用了一个会抛出异常的方法，它把表达式的评估结果转换为一个Optional。例如，咱们让working返回一个Int：

func working(robot: Robot) throws -> Int {
    defer {
        try! robot.action(Command.Shutdown)
    }

    do {
        try robot.action(Command.PowerUp)
        try robot.action(Command.Lifting(52))
    }
    catch let RobotError.LowPower(percentage) {
        print("Low power: \(percentage)")
    }
    catch let RobotError.Overload(maxWeight) {
        print("Overloading, max \(maxWeight) KG is allowd")
    }

    return 0
}

从上面的代码里能够看到，当函数有返回值的时候，咱们要把throws写在返回值前面。

而后，咱们查看working的返回值和类型：

let a = try? working(iRobot)
print("value: \(a)\n type: \(a.dynamicType)")

这里，因为咱们处理异常，所以a的值是0，可是，a的类型，是一个Optional<Int>。

若是咱们把RobotError.Overload注释掉，而后让Robot举起超过100KG的物体：

func working(robot: Robot) throws -> Int {
    defer {
        try! robot.action(Command.Shutdown)
    }

    do {
        try robot.action(Command.PowerUp)
        try robot.action(Command.Lifting(152))
    }
    catch let RobotError.LowPower(percentage) {
        print("Low power: \(percentage)")
    }
    /*catch let RobotError.Overload(maxWeight) {
        print("Overloading, max \(maxWeight) KG is allowd")
    }*/

    return 0
}

这样异常就会被抛到working外围，此时Swift运行时会捕捉到这个异常，而且，把a的值设置成nil：

let a = try? working(iRobot)
print("value: \(a)\n type: \(a.dynamicType)")

接下来？在下一段中，咱们将向你们介绍多线程环境中的异常处理。