为有牺牲多壮志，敢教日月换新天。

Swift5.4 语言指南(十九) 错误处理

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9739443.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

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

某些操作不能保证总是完成执行或产生有用的输出。可选变量用于表示缺少值，但是当操作失败时，了解导致失败的原因通常很有用，以便您的代码可以做出相应的响应。

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

笔记

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语句引发错误。例如，以下代码引发错误，以指示自动售货机需要另外五个硬币：

  1. throw VendingMachineError.insufficientFunds(coinsNeeded: 5)

处理错误

引发错误时，周围的某些代码段必须负责处理错误，例如，通过更正问题，尝试其他方法或将故障通知用户。

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

当一个函数抛出错误时，它会改变程序的流程，因此，重要的是，您必须快速识别代码中可能引发错误的位置。要在代码中标识这些位置，请在一段调用可能会引发错误的函数，方法或初始化程序的代码之前，写上try关键字（或thetry?或try!variant）。这些关键字在以下各节中进行介绍。

笔记

错误迅速处理类似的异常处理在其他语言中，使用了的try，catch和throw关键字。与许多语言（包括Objective-C）中的异常处理不同，Swift中的错误处理并不涉及展开调用堆栈，该过程在计算上可能会非常昂贵。这样，throw语句的性能特征可与语句的性能特征相媲美return。

使用投掷函数传播错误

为了表明函数，方法或初始化程序可能引发错误，请throws在函数的参数后的声明中写入关键字。标throws有的功能称为投掷功能。如果函数指定了返回类型，则将throws关键字写在返回箭头（->）之前。

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

抛出函数会将抛出的错误传播到调用它的作用域中。

笔记

只有throwing函数可以传播错误。抛出于非抛出函数内部的任何错误都必须在函数内部进行处理。

在下面的示例中，VendingMachine该类具有一个vend(itemNamed:)方法，VendingMachineError如果所请求的物料不可用，缺货或成本超过当前的存放量，则该方法将抛出适当的值：

  1. struct Item {
  2. var price: Int
  3. var count: Int
  4. }
  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
  14. func vend(itemNamed name: String) throws {
  15. guard let item = inventory[name] else {
  16. throw VendingMachineError.invalidSelection
  17. }
  19. guard item.count > 0 else {
  20. throw VendingMachineError.outOfStock
  21. }
  23. guard item.price <= coinsDeposited else {
  24. throw VendingMachineError.insufficientFunds(coinsNeeded: item.price - coinsDeposited)
  25. }
  27. coinsDeposited -= item.price
  29. var newItem = item
  30. newItem.count -= 1
  31. inventory[name] = newItem
  33. print("Dispensing \(name)")
  34. }
  35. }

该vend(itemNamed:)方法的实现使用guard语句来提前退出该方法，如果不满足购买零食的任何要求，则抛出适当的错误。因为一条throw语句会立即转移程序控制权，所以只有在满足所有这些要求的情况下，才可以出售商品。

因为该vend(itemNamed:)方法传播了它抛出的任何错误，所以任何调用此方法的代码都必须使用do-catch语句try?，或try!-处理错误，或者继续传播它们。例如，buyFavoriteSnack(person:vendingMachine:)在下面的示例中，也是一个throwing函数，该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下面清单中的结构的初始化程序在初始化过程中调用了throwing函数，并通过将其传播给调用方来处理遇到的任何错误。

  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 pattern 3, pattern 4 where condition {
  9. statements
  10. } catch {
  11. statements
  12. }

之后写一个模式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子句，这些子句决定是否允许继续传播。如果没有匹配的模式，则该错误将被finalcatch子句捕获，并绑定到局部error常量。如果没有引发错误，do则执行该语句中的其余语句。

该catch条款没有处理每一个可能的错误，该代码do子句可以抛出。如果没有任何一个catch子句处理该错误，则该错误会传播到周围的范围。然而，传播错误必须处理一些周边范围。在非抛出函数中，必须使用do-catch语句处理该错误。在throwing函数中，封闭的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("Couldn't buy that from the vending machine.")
  6. }
  7. }
  9. do {
  10. try nourish(with: "Beet-Flavored Chips")
  11. } catch {
  12. print("Unexpected non-vending-machine-related error: \(error)")
  13. }
  14. // Prints "Couldn't buy that from the vending machine."

在该nourish(with:)函数中，如果vend(itemNamed:)引发VendingMachineError枚举情况之一nourish(with:)的错误，则通过打印消息来处理该错误。否则，nourish(with:)将错误传播到其呼叫站点。然后，该错误将被generalcatch子句捕获。

捕获几个相关错误的另一种方法是将它们列出在后面catch，并用逗号分隔。例如：

  1. func eat(item: String) throws {
  2. do {
  3. try vendingMachine.vend(itemNamed: item)
  4. } catch VendingMachineError.invalidSelection, VendingMachineError.insufficientFunds, VendingMachineError.outOfStock {
  5. print("Invalid selection, out of stock, or not enough money.")
  6. }
  7. }

该eat(item:)功能列出了要捕获的自动售货机错误，其错误文本与该列表中的项目相对应。如果抛出了列出的三个错误中的任何一个，则此catch子句通过打印消息来处理它们。其他任何错误都会传播到周围的范围，包括以后可能会添加的自动售货机错误。

将错误转换为可选值

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

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

如果someThrowingFunction()抛出错误，则xand的y值为nil。否则，xandy的值就是函数返回的值。请注意，x和y是someThrowingFunction()返回的可选类型。这里的函数返回一个整数，所以x和y是可选的整数。

try?当您要以相同方式处理所有错误时，使用using可以编写简洁的错误处理代码。例如，以下代码使用几种方法来获取数据，或者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:)函数，该函数在给定路径下加载图像资源，或者在无法加载图像时抛出错误。在这种情况下，由于该映像是与应用程序一起提供的，因此在运行时不会引发任何错误，因此应该禁用错误传播。

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

指定清理措施

您可以defer在代码执行离开当前代码块之前使用一条语句来执行一组语句。通过该语句，无论执行如何离开当前代码块，无论是由于引发错误还是由于诸如return或之类的语句而离开，您都可以执行该操作break。例如，您可以使用一条defer语句来确保关闭文件描述符并释放手动分配的内存。

一条defer语句将延迟执行，直到退出当前作用域。该语句由defer关键字和以后要执行的语句组成。延迟的语句可能不包含任何将控制权移出该语句的代码，例如abreak或一条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即使不涉及任何错误处理代码，也可以使用语句。

 
posted @ 2018-10-03 11:30  为敢技术  阅读(647)  评论(0)  编辑  收藏  举报