Swift do-try-catch语法

我尝试理解Swift 2中的新错误处理方法。这是我做的：我首先声明了一个错误枚举：

enum SandwichError: ErrorType {
    case NotMe
    case DoItYourself
}

然后我声明了一个引发错误的方法（伙计们不是异常。这是一个错误。）。这是该方法：

func makeMeSandwich(names: [String: String]) throws -> String {
    guard let sandwich = names["sandwich"] else {
        throw SandwichError.NotMe
    }

    return sandwich
}

问题出在呼叫方。这是调用此方法的代码：

let kitchen = ["sandwich": "ready", "breakfeast": "not ready"]

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch SandwichError.NotMe {
    print("Not me error")
} catch SandwichError.DoItYourself {
    print("do it error")
}

之后，do行编译器说Errors thrown from here are not handled because the enclosing catch is not exhaustive。但是我认为这是详尽无遗的，因为SandwichError枚举中只有两种情况。

对于常规的switch语句，swift可以理解，在处理每种情况时，它都是详尽的。

Swift 2错误处理模型有两个重要方面：详尽性和弹性。它们一起归结为您的do/ catch语句，需要捕获所有可能的错误，而不仅仅是您知道可以抛出的错误。

请注意，您并未声明函数会抛出什么类型的错误，仅声明它是否会抛出任何类型的错误。这是一个零一无穷的问题：当有人为其他人（包括您将来的自己）定义一个函数供您使用时，您不必让函数的每个客户端都适应您实现中的每个更改功能，包括它可能引发的错误。您希望调用您的函数的代码能够适应这种变化。

因为您的函数无法说出它抛出的错误类型（或将来可能抛出的错误），所以catch捕获该错误的块不知道它可能抛出的错误类型。因此，除了处理您所知道的错误类型之外，您还需要使用通用catch语句来处理那些您不知道的错误类型，这样，如果您的函数更改了将来抛出的错误集，则调用方仍将捕获该错误类型。错误。

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch SandwichError.NotMe {
    print("Not me error")
} catch SandwichError.DoItYourself {
    print("do it error")
} catch let error {
    print(error.localizedDescription)
}

但是，我们不要就此止步。再考虑一下这种弹性思想。设计三明治的方式必须在每个使用位置描述错误。这意味着，每当更改错误案例集时，都必须更改使用它们的每个位置……这不是很有趣。

定义自己的错误类型的想法是让您集中处理这样的事情。您可以description为错误定义一个方法：

extension SandwichError: CustomStringConvertible {
    var description: String {
        switch self {
            case NotMe: return "Not me error"
            case DoItYourself: return "Try sudo"
        }
    }
}

然后，您的错误处理代码可以要求您的错误类型进行自我描述-现在，您处理错误的每个地方都可以使用相同的代码，并且还可以处理将来可能发生的错误情况。

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch let error as SandwichError {
    print(error.description)
} catch {
    print("i dunno")
}

这也为错误类型（或其扩展）支持其他报告错误的方式铺平了道路-例如，您可以在错误类型上拥有扩展名，该扩展名知道如何向UIAlertControlleriOS用户报告错误。

我怀疑这只是尚未正确实施。《Swift编程指南》绝对似乎暗示编译器可以“像switch语句”推断出详尽的匹配项。它并没有提到需要一个通用catch的才能穷举。

您还会注意到错误try在行上，而不是代码块的末尾，即在某个时候，编译器将能够查明代码try块中的哪个语句具有未处理的异常类型。

但是文档有点含糊。我浏览了“ Swift的新功能”视频，找不到任何线索。我会继续努力。

更新：

现在，我们可以使用Beta 3，而不会提示ErrorType推断。我现在相信，如果曾经计划过（并且我仍然认为是在某个时候），那么协议扩展的动态调度可能会杀死它。

Beta 4更新：

Xcode 7b4添加了对的文档注释支持Throws:，“应用于记录可能引发的错误和原因”。我猜这至少提供了一些机制来将错误传达给API使用者。有文档时谁需要类型系统！

另一个更新：

花了一些时间希望自动ErrorType推理并弄清楚该模型的局限性之后，我改变了主意- 这是我希望Apple能够实现的。本质上：

// allow us to do this:
func myFunction() throws -> Int

// or this:
func myFunction() throws CustomError -> Int

// but not this:
func myFunction() throws CustomErrorOne, CustomErrorTwo -> Int

另一个更新

Apple的错误处理原理现在可以在此处获得。快速发展邮件列表上也进行了一些有趣的讨论。本质上，John McCall反对键入错误，因为他认为大多数库无论如何都会最终包含一个通用错误情况，而且除了样板外，键入错误不太可能给代码增加太多（他使用了“期望虚张声势”一词）。克里斯·拉特纳（Chris Lattner）表示，如果它可以与弹性模型一起使用，他愿意接受Swift 3中的键入错误。

Swift担心您的case语句不能涵盖所有情况，要解决该问题，您需要创建一个默认case：

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch SandwichError.NotMe {
    print("Not me error")
} catch SandwichError.DoItYourself {
    print("do it error")
} catch Default {
    print("Another Error")
}

我也对缺少函数可以抛出的类型感到失望，但是由于@rickster我现在就明白了，我将这样总结一下：假设我们可以指定函数抛出的类型，那么我们会有这样的东西：

enum MyError: ErrorType { case ErrorA, ErrorB }

func myFunctionThatThrows() throws MyError { ...throw .ErrorA...throw .ErrorB... }

do {
    try myFunctionThatThrows()
}
case .ErrorA { ... }
case .ErrorB { ... }

问题是，即使我们不更改myFunctionThatThrows中的任何内容，只要将错误情况添加到MyError中：

enum MyError: ErrorType { case ErrorA, ErrorB, ErrorC }

我们被搞砸了，因为我们的do / try / catch不再是详尽无遗的，以及我们调用抛出MyError的函数的任何其他地方

enum NumberError: Error {
  case NegativeNumber(number: Int)
  case ZeroNumber
  case OddNumber(number: Int)
}

extension NumberError: CustomStringConvertible {
         var description: String {
         switch self {
             case .NegativeNumber(let number):
                 return "Negative number \(number) is Passed."
             case .OddNumber(let number):
                return "Odd number \(number) is Passed."
             case .ZeroNumber:
                return "Zero is Passed."
      }
   }
}

 func validateEvenNumber(_ number: Int) throws ->Int {
     if number == 0 {
        throw NumberError.ZeroNumber
     } else if number < 0 {
        throw NumberError.NegativeNumber(number: number)
     } else if number % 2 == 1 {
         throw NumberError.OddNumber(number: number)
     }
    return number
}

现在验证号码：

 do {
     let number = try validateEvenNumber(0)
     print("Valid Even Number: \(number)")
  } catch let error as NumberError {
     print(error.description)
  }

创建这样的枚举：

//Error Handling in swift
enum spendingError : Error{
case minus
case limit
}

创建方法如下：

 func calculateSpending(morningSpending:Double,eveningSpending:Double) throws ->Double{
if morningSpending < 0 || eveningSpending < 0{
    throw spendingError.minus
}
if (morningSpending + eveningSpending) > 100{
    throw spendingError.limit
}
return morningSpending + eveningSpending
}

现在检查错误是否存在并进行处理：

do{
try calculateSpending(morningSpending: 60, eveningSpending: 50)
} catch spendingError.minus{
print("This is not possible...")
} catch spendingError.limit{
print("Limit reached...")
}