某个错误被抛出时,附近的某部分代码必须负责处理这个错误,例如纠正这个问题、尝试另外一种方式、或是向用户报告错误。
Swift 中有 4
种处理错误的方式。你可以把函数抛出的错误传递给调用此函数的代码、用 do-catch
语句处理错误、将错误作为可选类型处理、或者断言此错误根本不会发生。每种方式在下面的小节中都有描述。
当一个函数抛出一个错误时,你的程序流程会发生改变,所以重要的是你能迅速识别代码中会抛出错误的地方。为了标识出这些地方,在调用一个能抛出错误的函数、方法或者构造器之前,加上 try
关键字,或者 try?
或 try!
这种变体。这些关键字在下面的小节中有具体讲解。
注意
Swift 中的错误处理和其他语言中用
try
,catch
和throw
进行异常处理很像。和其他语言中(包括 Objective-C )的异常处理不同的是,Swift 中的错误处理并不涉及解除调用栈,这是一个计算代价高昂的过程。就此而言,throw
语句的性能特性是可以和return
语句相媲美的。
用 throwing 函数传递错误
为了表示一个函数、方法或构造器可以抛出错误,在函数声明的参数之后加上 throws
关键字。一个标有 throws
关键字的函数被称作 throwing 函数。如果这个函数指明了返回值类型,throws
关键词需要写在返回箭头(->
)的前面。
func canThrowErrors() throws -> String
func cannotThrowErrors() -> String
一个 throwing 函数可以在其内部抛出错误,并将错误传递到函数被调用时的作用域。
注意
只有 throwing 函数可以传递错误。任何在某个非 throwing 函数内部抛出的错误只能在函数内部处理。
下面的例子中,VendingMachine
类有一个 vend(itemNamed:)
方法,如果请求的物品不存在、缺货或者投入金额小于物品价格,该方法就会抛出一个相应的 VendingMachineError
:
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
func vend(itemNamed name: String) throws {
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)")
}
}
在 vend(itemNamed:)
方法的实现中使用了 guard
语句来确保在购买某个物品所需的条件中有任一条件不满足时,能提前退出方法并抛出相应的错误。由于 throw
语句会立即退出方法,所以物品只有在所有条件都满足时才会被售出。
因为 vend(itemNamed:)
方法会传递出它抛出的任何错误,在你的代码中调用此方法的地方,必须要么直接处理这些错误——使用 do-catch
语句,try?
或 try!
;要么继续将这些错误传递下去。例如下面例子中,buyFavoriteSnack(person:vendingMachine:)
同样是一个 throwing 函数,任何由 vend(itemNamed:)
方法抛出的错误会一直被传递到 buyFavoriteSnack(person:vendingMachine:)
函数被调用的地方。
let favoriteSnacks = [
"Alice": "Chips",
"Bob": "Licorice",
"Eve": "Pretzels",
]
func buyFavoriteSnack(person: String, vendingMachine: VendingMachine) throws {
let snackName = favoriteSnacks[person] ?? "Candy Bar"
try vendingMachine.vend(itemNamed: snackName)
}
上例中,buyFavoriteSnack(person:vendingMachine:)
函数会查找某人最喜欢的零食,并通过调用 vend(itemNamed:)
方法来尝试为他们购买。因为 vend(itemNamed:)
方法能抛出错误,所以在调用它的时候在它前面加了 try
关键字。
throwing
构造器能像 throwing
函数一样传递错误。例如下面代码中的 PurchasedSnack
构造器在构造过程中调用了 throwing 函数,并且通过传递到它的调用者来处理这些错误。
struct PurchasedSnack {
let name: String
init(name: String, vendingMachine: VendingMachine) throws {
try vendingMachine.vend(itemNamed: name)
self.name = name
}
}
用 Do-Catch 处理错误
你可以使用一个 do-catch
语句运行一段闭包代码来处理错误。如果在 do
子句中的代码抛出了一个错误,这个错误会与 catch
子句做匹配,从而决定哪条子句能处理它。
下面是 do-catch
语句的一般形式:
do {
try expression
statements
} catch pattern 1 {
statements
} catch pattern 2 where condition {
statements
} catch pattern 3, pattern 4 where condition {
statements
} catch {
statements
}
在 catch
后面写一个匹配模式来表明这个子句能处理什么样的错误。如果一条 catch
子句没有指定匹配模式,那么这条子句可以匹配任何错误,并且把错误绑定到一个名字为 error
的局部常量。关于模式匹配的更多信息请参考 模式。
举例来说,下面的代码处理了 VendingMachineError
枚举类型的全部三种情况:
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.”
上面的例子中,buyFavoriteSnack(person:vendingMachine:)
函数在一个 try
表达式中被调用,是因为它能抛出错误。如果错误被抛出,相应的执行会马上转移到 catch
子句中,并判断这个错误是否要被继续传递下去。如果错误没有被匹配,它会被最后一个 catch
语句捕获,并赋值给一个 error
常量。如果没有错误被抛出,do
子句中余下的语句就会被执行。
catch
子句不必将 do
子句中的代码所抛出的每一个可能的错误都作处理。如果所有 catch
子句都未处理错误,错误就会传递到周围的作用域。然而,错误还是必须要被某个周围的作用域处理的。在不会抛出错误的函数中,必须用 do-catch
语句处理错误。而能够抛出错误的函数既可以使用 do-catch
语句处理,也可以让调用方来处理错误。如果错误传递到了顶层作用域却依然没有被处理,你会得到一个运行时错误。
以下面的代码为例,不是 VendingMachineError
中声明的错误会在调用函数的地方被捕获:
func nourish(with item: String) throws {
do {
try vendingMachine.vend(itemNamed: item)
} catch is VendingMachineError {
print("Couldn't buy that from the vending machine.")
}
}
do {
try nourish(with: "Beet-Flavored Chips")
} catch {
print("Unexpected non-vending-machine-related error: \(error)")
}
// 打印“Couldn't buy that from the vending machine.”
如果 vend(itemNamed:)
抛出的是一个 VendingMachineError
类型的错误,nourish(with:)
会打印一条消息,否则 nourish(with:)
会将错误抛给它的调用方。这个错误之后会被通用的 catch
语句捕获。
另一种捕获多个相关错误的方式是将它们放在 catch
后,通过逗号分隔。例如:
func eat(item: String) throws {
do {
try vendingMachine.vend(itemNamed: item)
} catch VendingMachineError.invalidSelection, VendingMachineError.insufficientFunds, VendingMachineError.outOfStock {
print("Invalid selection, out of stock, or not enough money.")
}
}
eat(item:)
函数捕获了列出来的 VendingMachine
错误,且它的错误文本和列表的错误相关。如果列出来的三个错误中任意一个抛出,这个 catch
代码块就会打印信息。其他错误会传递到外面的作用域,包括以后可能添加的其他 VendingMachine
错误。
将错误转换成可选值
可以使用 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
都是这个类型的可选类型。例子中此函数返回一个整型,所以 x
和 y
是可选整型。
如果你想对所有的错误都采用同样的方式来处理,用 try?
就可以让你写出简洁的错误处理代码。例如,下面的代码用几种方式来获取数据,如果所有方式都失败了则返回 nil
。
func fetchData() -> Data? {
if let data = try? fetchDataFromDisk() { return data }
if let data = try? fetchDataFromServer() { return data }
return nil
}
禁用错误传递
有时你知道某个 throwing
函数实际上在运行时是不会抛出错误的,在这种情况下,你可以在表达式前面写 try!
来禁用错误传递,这会把调用包装在一个不会有错误抛出的运行时断言中。如果真的抛出了错误,你会得到一个运行时错误。
例如,下面的代码使用了 loadImage(atPath:)
函数,该函数从给定的路径加载图片资源,如果图片无法载入则抛出一个错误。在这种情况下,因为图片是和应用绑定的,运行时不会有错误抛出,所以适合禁用错误传递。
let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")