Swift-错误处理,throwing、Do-Catch、指定清理

  • 错误处理(Error handling) 是响应错误以及从错误中恢复的过程。
  • Swift 在运行时提供了抛出、捕获、传递和操作可恢复错误(recoverable errors)的一等支持(first-class support)。

1. 表示与抛出错误

  • 在 Swift 中,错误用遵循 Error 协议的类型的值来表示。这个空协议表明该类型可以用于错误处理。
  • Swift 的枚举类型尤为适合构建一组相关的错误状态,枚举的关联值还可以提供错误状态的额外信息。
enum VendingMachineError: Error {
    case invalidSelection                     //选择无效
    case insufficientFunds(coinsNeeded: Int) //金额不足
    case outOfStock                             //缺货
}
  • 抛出一个错误可以让你表明有意外情况发生,导致正常的执行流程无法继续执行。
  • 抛出错误使用 throw 语句。
throw VendingMachineError.insufficientFunds(coinsNeeded: 5)

2. 处理错误

  • 某个错误被抛出时,附近的某部分代码必须负责处理这个错误,例如纠正这个问题、尝试另外一种方式、或是向用户报告错误。
  • Swift 中有 4 种处理错误的方式。
    • 你可以把函数抛出的错误传递给调用此函数的代码。
    • 用 do-catch 语句处理错误。
    • 将错误作为可选类型处理。
    • 或者断言此错误根本不会发生。

注意:

  1. Swift 中的错误处理和其他语言中用 try,catch 和 throw 进行异常处理很像。
  2. 和其他语言中(包括 Objective-C )的异常处理不同的是,Swift 中的错误处理并不涉及解除调用栈,这是一个计算代价高昂的过程。就此而言,throw 语句的性能特性是可以和 return 语句相媲美的。

2.1 用 throwing 函数传递错误

  • 为了表示一个函数、方法或构造器可以抛出错误,在函数声明的参数之后加上 throws 关键字。
  • 一个标有 throws 关键字的函数被称作 throwing 函数。
  • 如果这个函数指明了返回值类型,throws 关键词需要写在返回箭头(->)的前面。
func canThrowErrors() throws -> String
func cannotThrowErrors() -> String
  • 一个 throwing 函数可以在其内部抛出错误,并将错误传递到函数被调用时的作用域。
struct Item {
    var price: Int
    var count: Int
}

class VendingMachine {
    var inventory = [
        "Candy Bar": Item(price: 12, count: 7),
        "Chips": Item(price: 10, count: 4),
        "Pretzels": Item(price: 7, count: 11)
    ]
    var coinsDeposited = 0
    
    /*
    vend(itemNamed:) 方法
    如果请求的物品不存在、缺货或者投入金额小于物品价格
    该方法就会抛出一个相应的 VendingMachineError
    */
    func vend(itemNamed name: String) throws {  
        /*
        使用了 guard 语句
        确保在购买某个物品所需的条件中有任一条件不满足时
        能提前退出方法并抛出相应的错误。
        */
        guard let item = inventory[name] else {
            throw VendingMachineError.invalidSelection
        }

        guard item.count > 0 else {
            throw VendingMachineError.outOfStock
        }

        guard item.price <= coinsDeposited else {
            throw VendingMachineError.insufficientFunds(coinsNeeded: item.price - coinsDeposited)
        }

        coinsDeposited -= item.price

        var newItem = item
        newItem.count -= 1
        inventory[name] = newItem

        print("Dispensing \(name)")
    }
}

let favoriteSnacks = [
    "Alice": "Chips",
    "Bob": "Licorice",
    "Eve": "Pretzels",
]

/*
buyFavoriteSnack(person:vendingMachine:) 同样是一个 throwing 函数
任何由 vend(itemNamed:) 方法抛出的错误会一直被传递到 buyFavoriteSnack(person:vendingMachine:) 函数被调用的地方。
*/
func buyFavoriteSnack(person: String, vendingMachine: VendingMachine) throws {
    /*
    buyFavoriteSnack(person:vendingMachine:) 
    函数会查找某人最喜欢的零食
    并通过调用 vend(itemNamed:) 方法来尝试为他们购买
    因为 vend(itemNamed:) 方法能抛出错误,所以在调用它的时候在它前面加了 try 关键字。
    */
    let snackName = favoriteSnacks[person] ?? "Candy Bar"
    try vendingMachine.vend(itemNamed: snackName)
}

  • throwing 构造器能像 throwing 函数一样传递错误。
/*
PurchasedSnack 构造器在构造过程中调用了 throwing 函数
并且通过传递到它的调用者来处理这些错误。
*/
struct PurchasedSnack {
    let name: String
    init(name: String, vendingMachine: VendingMachine) throws {
        try vendingMachine.vend(itemNamed: name)
        self.name = name
    }
}

2.2 用 Do-Catch 处理错误

  • 可以使用一个 do-catch 语句运行一段闭包代码来处理错误。
  • 如果在 do 子句中的代码抛出了一个错误,这个错误会与 catch 子句做匹配,从而决定哪条子句能处理它。
do {
    try expression
    statements
} catch pattern 1 {
    statements
} catch pattern 2 where condition {
    statements
} catch {
    statements
}
  • 在 catch 后面写一个匹配模式来表明这个子句能处理什么样的错误。
  • 如果一条 catch 子句没有指定匹配模式,那么这条子句可以匹配任何错误,并且把错误绑定到一个名字为 error 的局部常量。
var vendingMachine = VendingMachine()
vendingMachine.coinsDeposited = 8
do {
    try buyFavoriteSnack(person: "Alice", vendingMachine: vendingMachine)
    print("Success! Yum.")
} catch VendingMachineError.invalidSelection {
    print("Invalid Selection.")
} catch VendingMachineError.outOfStock {
    print("Out of Stock.")
} catch VendingMachineError.insufficientFunds(let coinsNeeded) {
    print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.")
} catch {
    print("Unexpected error: \(error).")
}   // 打印“Insufficient funds. Please insert an additional 2 coins.”
  1. buyFavoriteSnack(person:vendingMachine:) 函数在一个 try 表达式中被调用,是因为它能抛出错误。
  2. 如果错误被抛出,相应的执行会马上转移到 catch 子句中,并判断这个错误是否要被继续传递下去。
  3. 如果错误没有被匹配,它会被最后一个 catch 语句捕获,并赋值给一个 error 常量。
  4. 如果没有错误被抛出,do 子句中余下的语句就会被执行。

catch 子句不必将 do 子句中的代码所抛出的每一个可能的错误都作处理。
如果所有 catch 子句都未处理错误,错误就会传递到周围的作用域。
然而,错误还是必须要被某个周围的作用域处理的。
在不会抛出错误的函数中,必须用 do-catch 语句处理错误。
而能够抛出错误的函数既可以使用 do-catch 语句处理,也可以让调用方来处理错误。
如果错误传递到了顶层作用域却依然没有被处理,你会得到一个运行时错误。

func nourish(with item: String) throws {
    do {
        try vendingMachine.vend(itemNamed: item)
    } catch is VendingMachineError {
        print("Invalid selection, out of stock, or not enough money.")
    }
}

do {
    try nourish(with: "Beet-Flavored Chips")
} catch {
    print("Unexpected non-vending-machine-related error: \(error)")
}   // 打印“Invalid selection, out of stock, or not enough money.”

如果 vend(itemNamed:) 抛出的是一个 VendingMachineError 类型的错误,nourish(with:) 会打印一条消息。
否则 nourish(with:) 会将错误抛给它的调用方。
这个错误之后会被通用的 catch 语句捕获。

2.3 将错误转换成可选值

  • 可以使用 try? 通过将错误转换成一个可选值来处理错误。
  • 如果是在计算 try? 表达式时抛出错误,该表达式的结果就为 nil。
  • 在下面的代码中,x 和 y 有着相同的数值和等价的含义:
func someThrowingFunction() throws -> Int {
    // ...
}

let x = try? someThrowingFunction()

let y: Int?
do {
    y = try someThrowingFunction()
} catch {
    y = nil
}

如果 someThrowingFunction() 抛出一个错误,x 和 y 的值是 nil。
否则 x 和 y 的值就是该函数的返回值。

注意:无论 someThrowingFunction() 的返回值类型是什么类型,x 和 y 都是这个类型的可选类型。
  • 如果你想对所有的错误都采用同样的方式来处理,用 try? 就可以让你写出简洁的错误处理代码。
func fetchData() -> Data? {
    if let data = try? fetchDataFromDisk() { return data }
    if let data = try? fetchDataFromServer() { return data }
    return nil
}

代码用几种方式来获取数据,如果所有方式都失败了则返回 nil。

2.4 禁用错误传递

  • 有时你知道某个 throwing 函数实际上在运行时是不会抛出错误的,在这种情况下,你可以在表达式前面写 try! 来禁用错误传递,这会把调用包装在一个不会有错误抛出的运行时断言中。如果真的抛出了错误,你会得到一个运行时错误。
  • 使用了 loadImage(atPath:) 函数,该函数从给定的路径加载图片资源,如果图片无法载入则抛出一个错误。在这种情况下,因为图片是和应用绑定的,运行时不会有错误抛出,所以适合禁用错误传递。
let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")

3. 指定清理操作

  • 使用 defer 语句在即将离开当前代码块时执行一系列语句。
  • 该语句让你能执行一些必要的清理工作,不管是以何种方式离开当前代码块的——无论是由于抛出错误而离开,或是由于诸如 return、break 的语句。
  • 可以用 defer 语句来确保文件描述符得以关闭,以及手动分配的内存得以释放。
  • defer 语句将代码的执行延迟到当前的作用域退出之前。
  • 该语句由 defer 关键字和要被延迟执行的语句组成。
  • 延迟执行的语句不能包含任何控制转移语句,例如 break、return 语句,或是抛出一个错误。
  • 延迟执行的操作会按照它们声明的顺序从后往前执行——也就是说,第一条 defer 语句中的代码最后才执行,第二条 defer 语句中的代码倒数第二个执行,以此类推。最后一条语句会第一个执行。
func processFile(filename: String) throws {
    if exists(filename) {
        let file = open(filename)
        defer {
            close(file)
        }
        while let line = try file.readline() {
            // 处理文件。
        }
        // close(file) 会在这里被调用,即作用域的最后。
    }
}

上面的代码使用一条 defer 语句来确保 open(:) 函数有一个相应的对 close(:) 函数的调用。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值