Swift4.2语言规范(十九) 错误处理

发布时间：2020-12-14 05:11:37 所属栏目：百科来源：网络整理

导读：错误处理是响应程序中的错误条件并从中恢复的过程。 Swift为在运行时抛出，捕获，传播和操纵可恢复的错误提供了一流的支持。某些操作无法保证始终完成执行或产生有用的输出。 Optionals用于表示缺少值，但是当操作失败时，了解导致失败的原因通常很有用，

错误处理是响应程序中的错误条件并从中恢复的过程。Swift为在运行时抛出，捕获，传播和操纵可恢复的错误提供了一流的支持。

某些操作无法保证始终完成执行或产生有用的输出。Optionals用于表示缺少值，但是当操作失败时，了解导致失败的原因通常很有用，这样您的代码就可以做出相应的响应。

例如，考虑从磁盘上的文件读取和处理数据的任务。此任务可能有多种失败方式，包括指定路径中不存在的文件，没有读取权限的文件或未以兼容格式编码的文件。区分这些不同的情况允许程序解决一些错误并向用户传达它无法解决的任何错误。

注意

Swift中的错误处理与使用NSErrorCocoa和Objective-C中的类的错误处理模式互操作。有关此类的更多信息，请参阅处理Swift中的错误处理。

抛出错误

在Swift中，错误由符合Error协议的类型的值表示。此空协议表示类型可用于错误处理。

Swift枚举特别适合于对一组相关错误条件进行建模，其中相关值允许有关要传达的错误性质的附加信息。例如，以下是您如何表示在游戏中操作自动售货机的错误条件：

1 enum VendingMachineError: Error {
2     case invalidSelection
3     case insufficientFunds(coinsNeeded: Int)
4     case outOfStock
5 }

抛出错误可以指示发生了意外情况，并且正常的执行流程无法继续。您使用throw语句来抛出错误。例如，以下代码抛出一个错误，表示自动售货机需要另外五个硬币：

throw VendingMachineError.insufficientFunds(coinsNeeded: 5)

处理错误

当抛出错误时，一些周围的代码必须负责处理错误 - 例如，通过纠正问题，尝试替代方法或通知用户失败。

有四种方法可以处理Swift中的错误。您可以将错误从函数传播到调用该函数的代码，使用do-?catch语句处理错误，将错误作为可选值处理，或断言错误不会发生。每种方法都在下面的部分中描述。

当函数抛出错误时，它会改变程序的流程，因此您可以快速识别代码中可能引发错误的位置，这一点很重要。要在代码中标识这些位置，请在调用可能引发错误的函数，方法或初始值设定项的代码之前编写try关键字 - 或者try?或try!变体 - 。这些关键字在以下部分中描述。

注意

在Swift的错误处理类似的异常处理在其他语言中，使用了的try，catch和throw关键字。与许多语言中的异常处理不同 - 包括Swift中的Objective-C错误处理不涉及展开调用堆栈，这个过程可能在计算上很昂贵。因此，throw声明的性能特征与声明的性能特征相当return。

使用Throw函数传播错误

要指示函数，方法或初始值设定项可以抛出错误，请throws在函数声明的参数后面写入关键字。标throws有的功能称为投掷功能。如果函数指定了返回类型，则throws在返回箭头（->）之前编写关键字。

1 func canThrowErrors() throws -> String
2 
3 func cannotThrowErrors() -> String

抛出函数将在其中抛出的错误传播到调用它的范围。

注意

只有抛出函数才能传播错误。必须在函数内部处理在非throwing函数内抛出的任何错误。

在下面的示例中，VendingMachine类具有一个vend(itemNamed:)方法，VendingMachineError如果请求的项目不可用，缺货或成本超过当前存入的金额，则抛出适当的方法：

 1 struct Item {
 2     var price: Int
 3     var count: Int
 4 }
 5 
 6 class VendingMachine {
 7     var inventory = [
 8         "Candy Bar": Item(price: 12,count: 7), 9         "Chips": Item(price: 10,count: 4),10         "Pretzels": Item(price: 7,count: 11)
11     ]
12     var coinsDeposited = 0
13 
14     func vend(itemNamed name: String) throws {
15         guard let item = inventory[name] else {
16             throw VendingMachineError.invalidSelection
17         }
18 
19         guard item.count > 0 else {
20             throw VendingMachineError.outOfStock
21         }
22 
23         guard item.price <= coinsDeposited else {
24             throw VendingMachineError.insufficientFunds(coinsNeeded: item.price - coinsDeposited)
25         }
26 
27         coinsDeposited -= item.price
28 
29         var newItem = item
30         newItem.count -= 1
31         inventory[name] = newItem
32 
33         print("Dispensing (name)")
34     }
35 }

该vend(itemNamed:)方法的实现使用guard语句提前退出方法，并且如果不满足购买零食的任何要求则抛出适当的错误。由于throw声明会立即转移程序控制，因此只有满足所有这些要求才会出现项目。

因为该vend(itemNamed:)方法传播它抛出的任何错误，所以调用此方法的任何代码都必须使用do-?catch语句来处理错误try?，或者try!- 或继续传播它们。例如，buyFavoriteSnack(person:vendingMachine:)下面的示例中也是一个抛出函数，并且该vend(itemNamed:)方法抛出的任何错误都将传播到buyFavoriteSnack(person:vendingMachine:)调用函数的位置。

1 let favoriteSnacks = [
2     "Alice": "Chips",3     "Bob": "Licorice",4     "Eve": "Pretzels",5 ]
6 func buyFavoriteSnack(person: String,vendingMachine: VendingMachine) throws {
7     let snackName = favoriteSnacks[person] ?? "Candy Bar"
8     try vendingMachine.vend(itemNamed: snackName)
9 }

在这个例子中，该函数查找给定人最喜欢的零食，并尝试通过调用该方法为他们购买。因为该方法可以抛出错误，所以使用前面的关键字调用它。buyFavoriteSnack(person:?vendingMachine:)vend(itemNamed:)vend(itemNamed:)try

抛出初始化器可以像抛出函数一样传播错误。例如，PurchasedSnack下面清单中结构的初始化程序将throw函数作为初始化过程的一部分调用，它通过将它们传播给调用者来处理它遇到的任何错误。

1 struct PurchasedSnack {
2     let name: String
3     init(name: String,vendingMachine: VendingMachine) throws {
4         try vendingMachine.vend(itemNamed: name)
5         self.name = name
6     }
7 }

使用Do-Catch处理错误

您使用do-?catch语句通过运行代码块来处理错误。如果do子句中的代码抛出错误，则将其与catch子句匹配以确定它们中的哪一个可以处理错误。

以下是do-?catch声明的一般形式：

 1 do {
 2     try expression
 3     statements
 4 } catch pattern 1 {
 5     statements
 6 } catch pattern 2 where condition {
 7     statements
 8 } catch {
 9     statements
10 }

您之后编写一个模式catch以指示该子句可以处理的错误。如果catch子句没有模式，则子句匹配任何错误并将错误绑定到名为的本地常量error。有关模式匹配的更多信息，请参阅模式。

例如，以下代码匹配VendingMachineError枚举的所有三种情况。

 1 var vendingMachine = VendingMachine()
 2 vendingMachine.coinsDeposited = 8
 3 do {
 4     try buyFavoriteSnack(person: "Alice",vendingMachine: vendingMachine)
 5     print("Success! Yum.")
 6 } catch VendingMachineError.invalidSelection {
 7     print("Invalid Selection.")
 8 } catch VendingMachineError.outOfStock {
 9     print("Out of Stock.")
10 } catch VendingMachineError.insufficientFunds(let coinsNeeded) {
11     print("Insufficient funds. Please insert an additional (coinsNeeded) coins.")
12 } catch {
13     print("Unexpected error: (error).")
14 }
15 // Prints "Insufficient funds. Please insert an additional 2 coins."

在上面的示例中，buyFavoriteSnack(person:vendingMachine:)函数在try表达式中调用，因为它可能会抛出错误。如果抛出错误，执行会立即转移到catch子句，该子句决定是否允许传播继续。如果没有匹配模式，则错误会被final?catch子句捕获并绑定到本地error常量。如果未引发错误，do则执行语句中的其余语句。

这些catch子句不必处理do子句中的代码可能抛出的每个可能的错误。如果没有catch子句处理错误，则错误将传播到周围的范围。但是，传播的错误必须由某些周围的范围处理。在非throwing函数中，enclosing?do-?catch子句必须处理错误。在投掷功能，无论是一个封闭do-?catch子句或调用者必须处理错误。如果错误传播到顶级作用域而未进行处理，则会出现运行时错误。

例如，可以编写上面的示例，以便VendingMachineError调用函数捕获任何非a的错误：

 1 func nourish(with item: String) throws {
 2     do {
 3         try vendingMachine.vend(itemNamed: item)
 4     } catch is VendingMachineError {
 5         print("Invalid selection,out of stock,or not enough money.")
 6     }
 7 }
 8 
 9 do {
10     try nourish(with: "Beet-Flavored Chips")
11 } catch {
12     print("Unexpected non-vending-machine-related error: (error)")
13 }
14 // Prints "Invalid selection,or not enough money."

在nourish(with:)函数中，如果vend(itemNamed:)抛出一个错误，这是VendingMachineError枚举的一种情况，则nourish(with:)通过打印消息来处理错误。否则，nourish(with:)将错误传播到其调用站点。然后由general?catch子句捕获该错误。

将错误转换为可选值

您可以try?通过将错误转换为可选值来处理错误。如果在计算try?表达式时抛出错误，则表达式的值为nil。例如，在下面的代码x，并y具有相同的价值和行为：

 1 func someThrowingFunction() throws -> Int {
 2     // ...
 3 }
 4 
 5 let x = try? someThrowingFunction()
 6 
 7 let y: Int?
 8 do {
 9     y = try someThrowingFunction()
10 } catch {
11     y = nil
12 }

如果someThrowingFunction()抛出错误，则为x和的值。否则，和的值是函数返回的值。请注意，并且是任何类型返回的可选项。在这里，函数返回一个整数，所以和是可选的整数。ynilxyxysomeThrowingFunction()xy

使用时，try?可以在以相同方式处理所有错误时编写简明的错误处理代码。例如，以下代码使用多种方法来获取数据，或者nil如果所有方法都失败则返回。

1 func fetchData() -> Data? {
2     if let data = try? fetchDataFromDisk() { return data }
3     if let data = try? fetchDataFromServer() { return data }
4     return nil
5 }

禁用错误传播

有时你知道抛出函数或方法实际上不会在运行时抛出错误。在这些情况下，您可以try!在表达式之前编写以禁用错误传播，并在运行时断言中包装调用，以便不会引发错误。如果实际抛出了错误，您将收到运行时错误。

例如，以下代码使用一个loadImage(atPath:)函数，该函数在给定路径上加载图像资源，或者如果无法加载图像则抛出错误。在这种情况下，由于映像随应用程序一起提供，因此运行时不会抛出任何错误，因此禁用错误传播是合适的。

let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")

指定清理操作

defer在代码执行离开当前代码块之前，您使用语句来执行一组语句。这种说法让你做应该无论进行任何必要的清理如何执行离开的代码是否当前块离开，因为一个错误被抛出，或者因为一个声明如return或break。例如，您可以使用defer语句来确保关闭文件描述符并释放手动分配的内存。

一defer直到当前范围退出声明推迟执行。该语句由defer关键字和稍后要执行的语句组成。延迟语句可能不包含任何将控制转移出语句的代码，例如a?break或return语句，或者抛出错误。延迟操作的执行顺序与它们在源代码中编写的顺序相反。也就是说，第一个defer语句中的代码最后执行，第二个defer语句中的代码执行倒数第二个，依此类推。defer源代码顺序中的最后一个语句首先执行。

 1 func processFile(filename: String) throws {
 2     if exists(filename) {
 3         let file = open(filename)
 4         defer {
 5             close(file)
 6         }
 7         while let line = try file.readline() {
 8             // Work with the file.
 9         }
10         // close(file) is called here,at the end of the scope.
11     }
12 }

上面的示例使用一个defer语句来确保该open(_:)函数具有相应的调用close(_:)。

注意

defer即使没有涉及错误处理代码，也可以使用语句。

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!