Swift 避免处理所有异常，直到它们'；我找到了一个全局处理程序

如果我调用

hello.f

，编译器会强制我处理所有抛出的异常。我可以使用

try？

吞下它们，或者通过不指定要捕获的异常类型然后重新抛出来添加一个

catch

全部。但是，如果执行后一种操作，则需要将调用函数标记为抛出，并且该过程将一直持续到堆栈上

是否可以忽略

f

的异常，使其最终成为可以全局处理的未处理异常

enum e : Error {
    case hello
    case world
}

class hello {
    func f() throws  {
        throw e.hello
    }
}

是否有可能忽略f的异常，使其最终成为可以全局处理的未处理异常

enum e : Error {
    case hello
    case world
}

class hello {
    func f() throws  {
        throw e.hello
    }
}

一句话，不。Swift错误处理设计的全部要点是，您必须明确承认每个阶段出现错误的可能性

在我看来，您似乎在思考Objective-C如何处理NSException，但Swift不是这样的（错误与NSException不同）

是否有可能忽略f的异常，使其最终成为可以全局处理的未处理异常

enum e : Error {
    case hello
    case world
}

class hello {
    func f() throws  {
        throw e.hello
    }
}

一句话，不。Swift错误处理设计的全部要点是，您必须明确承认每个阶段出现错误的可能性

---

在我看来，您似乎在思考Objective-C如何处理NSException，但Swift并非如此（错误与NSException不同）。

这正是我想要的。输出为“hello\n”。感谢holex对问题的评论

enum e : Error {
    case hello
    case world
}

class hello {
    func f() throws  {
        throw e.world
    }
}

class goodbye {
    func g() throws  {
        let h = hello()
        try h.f()
    }
}
class world {
    func w() throws  {
        let g = goodbye()
        try g.g()
    }
}

let w = world()
do {
try w.w()
}
catch e.world {
    print("hello")
}

---

这正是我想要的。输出为“hello\n”。感谢holex对问题的评论

enum e : Error {
    case hello
    case world
}

class hello {
    func f() throws  {
        throw e.world
    }
}

class goodbye {
    func g() throws  {
        let h = hello()
        try h.f()
    }
}
class world {
    func w() throws  {
        let g = goodbye()
        try g.g()
    }
}

let w = world()
do {
try w.w()
}
catch e.world {
    print("hello")
}

---

基于您的期望，我创建了以下示例：

enum PetError : Error {
    case pet
}

class Pet {
    func pet() throws  {
        throw PetError.pet
    }
}

class Cat {
    func cat() throws  {
        let pet = Pet()
        try pet.pet()
    }
}
class Tiger {
    func tiger() throws  {
        let cat = Cat()
        try cat.cat()
    }
}

---

然后，您可以在所需的最高级别上处理

PetError

异常（=错误），而在链内部，错误只是转发到更高级别

let tiger = Tiger()
do {
    try tiger.tiger()
} catch PetError.pet {
    print("PetError.pet")
}

---

---

注意：当然，您可能希望在一天结束时处理所有异常（=错误），但这不是这个小示例的一部分。

基于您的期望，我创建了以下示例：

enum PetError : Error {
    case pet
}

class Pet {
    func pet() throws  {
        throw PetError.pet
    }
}

class Cat {
    func cat() throws  {
        let pet = Pet()
        try pet.pet()
    }
}
class Tiger {
    func tiger() throws  {
        let cat = Cat()
        try cat.cat()
    }
}

---

然后，您可以在所需的最高级别上处理

PetError

异常（=错误），而在链内部，错误只是转发到更高级别

let tiger = Tiger()
do {
    try tiger.tiger()
} catch PetError.pet {
    print("PetError.pet")
}

---

---

---

注意：当然，您可能希望在一天结束时处理所有异常（=错误），但这不是这个小示例的一部分。

rethrows

似乎不在语言指南中。这超出了我的范围，我没有编写语言指南。：）你的标题是“避免处理所有异常”。请澄清你的意思。你说的“全球处理”是什么意思？我想你不能。这是设计的。Swift对错误处理更严格。@IanWarburton，是的，我修改了我在注释中快速编写的代码，这不是正确的语法，顺便说一句，但是你可以选择

func g（）抛出{try f（）}

这个，现在它是正确的，在这种情况下，您只需转发错误，而不在本地进行处理。

rethrows

似乎不在语言指南中。这超出了我的范围，我没有编写语言指南。：）你的标题是“避免处理所有异常”。请澄清你的意思。你说的“全球处理”是什么意思？我想你不能。这是设计的。Swift对错误处理更严格。@IanWarburton，是的，我修改了我在注释中快速编写的代码，这不是正确的语法，顺便说一句，但是你可以使用

func g（）抛出{try f（）}

这一点现在是正确的，在这种情况下，你只需转发错误而不在本地处理它。来自C#。。。我认为Anders Hejlsberg在这里提出了一个很好的论点。为什么不能使用

rethrows

？然后，您只需将责任传递给链中的前一个调用方。这不是OP想要的吗？实际上，

抛出

是我应该说的，而不是

重新抛出

@rmaddy，绝对不是“忽略”。正如我所说，这是承认。当然，我可能不明白伊恩在追求什么，但我认为他想在每个阶段都不说“扔”/

试试“扔”

，而是渗透整个链条，我说的没错，你不能这么做。@rmaddy当然。但我认为伊恩的意思是“忽略”。因为这就是响应者链的工作方式，以及Nseption处理在Objective-C中的工作方式：运行时只是在调用链上不断地寻找处理这件事的人。（但我的观点是，快速错误处理不是这样的：您必须在调用链的每一步都以某种方式进行处理。来自C#……我认为Anders Hejlsberg在这里对此提出了一个很好的论点……为什么不能使用

rethrows

呢？然后您只需将责任传递给链中的前一个调用方。这不是为什么实际上，

throws

是我应该说的，而不是

rethrows

@rmaddy，绝对不是“忽略”。正如我所说，这是承认。当然，我可能不明白伊恩在追求什么，但我认为他想在每个阶段都不说“扔”/

试试”

，而我说的没错，你不能那样做。@rmaddy当然。但我认为伊恩真的是指“忽略”。因为这就是响应者链的工作方式，以及N异常处理在Objective-C中的工作方式：运行时只是在调用链上不断地寻找处理这件事的人。（但我的观点是，快速错误处理不是这样的：你必须在调用链的每一步都以某种方式处理它。@holex我想与全世界分享更多我的命名约定。如果你回答，我会给你分数。@IanWarburton说到命名约定，类型名称应该是

UpperCamelCase

，例如

Hello

，

再见

，

世界<