Swift 异常处理以及注意事项在 Swift 中，throws 和 throw 是处理错误的关键字，它们用于标识和处理

在 Swift 中，throws 和 throw 是处理错误的关键字，它们用于标识和处理可能会产生错误的代码。但深入理解它们的工作机制有助于编写更健壮和可维护的代码。

`throws`

throws 用于标识一个函数或方法可能会抛出错误。任何标记为 throws 的函数在调用时必须在一个 do-catch 语句中处理，或者在调用链上继续使用 throws 关键字。

示例：

 func divide(_ numerator: Int, by denominator: Int) throws -> Int {
    if denominator == 0 {
        throw DivisionError.divideByZero
    }
    return numerator / denominator
 }

在这个例子中，divide 函数标记为 throws，因为它可能会抛出一个 DivisionError.divideByZero 错误。调用这个函数时，必须处理可能的错误：

 do {
    let result = try divide(10, by: 0)
    print(result)
 } catch {
    print("Error: (error)")
 }

`throw`

throw 用于实际抛出错误。你可以在 throws 声明的函数或方法中使用 throw 关键字抛出一个符合 Error 协议的类型。

示例：

 enum DivisionError: Error {
    case divideByZero
 }
 
 func divide(_ numerator: Int, by denominator: Int) throws -> Int {
    if denominator == 0 {
        throw DivisionError.divideByZero
    }
    return numerator / denominator
 }

在这个例子中，当 denominator 为 0 时，函数抛出一个 DivisionError.divideByZero 错误。

`rethrows`

除了 throws 关键字，Swift 还提供了一个 rethrows 关键字，它用于标识一个函数本身不抛出错误，但它的闭包参数可能会抛出错误。rethrows 可以减少不必要的错误处理代码，让函数调用更加简洁。

示例：

 func performOperation(_ operation: () throws -> Void) rethrows {
    try operation()
 }
 
 do {
    try performOperation(successfulOperation)
    print("No errors encountered.")
 } catch {
    print("An error occurred: (error)")
 }

在这个例子中，performOperation 函数接受一个可能抛出错误的闭包作为参数，并使用 rethrows 关键字标识。如果闭包抛出了错误，performOperation 将会将这个错误向上传递，但如果闭包不抛出错误，那么调用者就不需要处理错误。

异常的深入理解

1. 错误的编译层

Swift 的错误处理模型是基于 try、catch 以及 throws 和 throw 关键字的。throws 声明一个函数可以抛出错误，而 throw 则是在实际运行时抛出错误。

throws 关键字本质上是通过引入异常控制流来实现的。当一个 throws 函数被调用时，Swift 在内部生成一段额外的代码，用于检测函数是否抛出了错误。如果没有错误发生，函数会像普通函数一样返回结果；如果发生了错误，则会跳转到调用方的 catch 块进行处理。

这意味着 throws 和普通函数的调用在编译器层面有着不同的处理方式。在编译生成的中间代码中，throws 函数的返回值不是直接返回，而是封装在一个类似于 Result 类型的结构中，附带一个可能的错误对象。只有在 do-catch 块中，错误对象才会被解封和处理。

2. 错误的传播

在 Swift 中，错误传播是自动的。当你调用一个 throws 函数时，错误会自动沿着调用链向上传递，直到找到一个处理错误的 catch 块。如果没有捕获到错误，最终程序会崩溃。这种机制类似于传统的异常处理，但 Swift 明确了哪些函数可能会抛出错误，并强制开发者处理这些错误，从而提升了代码的健壮性。

3. 深入理解

重抛错误：在 catch 块中，如果你捕获到的错误不适合在当前范围内处理，你可以选择重抛错误，将错误继续向上传递：
```
 do {
    try divide(10, by: 0)
 } catch {
    print("An error occurred, rethrowing...")
    throw error
 }
```
转换错误：你还可以在 catch 块中将捕获到的错误转换为其他类型的错误，然后抛出新的错误。这样可以在不同的层次上更有语义地处理错误。
非抛出函数调用 throws 函数：一个非抛出函数可以调用一个 throws 函数，但必须在 do-catch 块中进行调用并处理错误。如果不希望调用者处理错误，也可以在 catch 中抑制错误（比如使用 try? 或 try!）。

`try?` 和 `try!` 的用法

try? : 当你不关心错误时，可以使用 try? 将 throws 函数的返回值转换为一个可选值。如果函数抛出错误，结果为 nil。

这种用法适合在某些非关键路径的错误处理场景中，比如尝试读取缓存数据，如果读取失败，可以返回 nil 并继续执行。
```
 let data = try? readFile(at: "path/to/file")
```
try! : 当你确信不会发生错误时，可以使用 try!。如果错误真的发生，程序将崩溃。try! 通常在开发和测试阶段用于快速验证逻辑，但在生产代码中应尽量避免使用。

`Result` 类型的使用

Swift 5 引入了 Result 类型，用于显式处理成功或失败的情况。与传统的 throws 不同，Result 类型允许你以更加函数式的方式处理错误。

示例：

 func divide(_ numerator: Int, by denominator: Int) -> Result<Int, DivisionError> {
    if denominator == 0 {
        return .failure(.divideByZero)
    } else {
        return .success(numerator / denominator)
    }
 }
 
 let result = divide(10, by: 0)
 switch result {
 case .success(let value):
    print("Result: (value)")
 case .failure(let error):
    print("Failed with error: (error)")
 }

使用 Result 可以避免 throws 的隐式控制流，特别是在处理异步代码时非常有用。

最佳实践

`throws` 和 `throw`

1. 避免滥用 `throws`

虽然 throws 是处理错误的一个非常强大的工具，但滥用它会导致代码难以维护。应尽量只在真正有意义的错误场景中使用 throws。对于一些可预见且不一定需要抛出错误的情况，考虑使用返回可选值（Optional）或者是结果类型（Result）来代替抛出错误。

2. 错误的局部化处理

在设计 API 时，应该尽量将错误的处理范围局限在合理的边界内，而不是将错误传播到整个应用程序的各个层次。局部化处理可以减少不必要的错误处理逻辑，使代码更加简洁。例如，如果一个函数中的错误在其内部就能得到合理的处理，那么尽量不要将其抛出给调用者。

3. 自定义错误类型的使用

Swift 允许你定义符合 Error 协议的自定义错误类型。对于复杂的应用程序，尤其是涉及到多个模块或层次的应用，建议使用自定义的错误类型，以便更好地组织和管理错误。自定义错误类型可以通过 enum 来实现，并且可以包含附加信息，使得错误处理更加具体和有意义。

 enum NetworkError: Error {
    case badURL
    case requestFailed(description: String)
    case responseUnsuccessful
    case jsonParsingFailure
 }

2. `try?` 和 `try!` 的使用注意事项

try? 的潜在问题：使用 try? 时，错误被隐式地忽略了，这可能导致难以调试的问题。虽然在某些情况下这可能是合理的，但在调试和分析错误时，你可能会错过一些重要的信息。为了避免这个问题，建议在开发过程中使用 try 并在 catch 块中明确处理错误，等到确认不需要处理错误时再切换为 try?。
try! 的风险：try! 表示你确信代码不会抛出错误，但如果错误真的发生，程序将会崩溃。虽然 try! 可以在某些测试场景下加快开发速度，但在生产代码中应尽量避免。可以考虑在测试时用断言（assert）替代 try!，这样可以在确保安全的前提下捕获潜在问题。

4. `Result` 类型的进阶用法

Swift 的 Result 类型为处理同步和异步操作中的成功或失败场景提供了更清晰的方式。在使用 Result 类型时，以下几点是需要特别注意的：

使用 map 和 flatMap: Result 类型支持 map 和 flatMap，允许你在保留错误处理的同时，对成功的结果进行链式操作。
```
 let result = divide(10, by: 2)
    .map { $0 * 2 }
    .flatMap { divide($0, by: 2) }
```
将 throws 函数转换为 Result 类型：在某些情况下，你可能希望将一个抛出错误的函数转换为返回 Result 的函数，这样可以避免使用 do-catch 结构。
```
 func divide(_ numerator: Int, by denominator: Int) -> Result<Int, DivisionError> {
    Result { try divide(numerator, by: denominator) }
 }
```

5. 异步错误处理

在处理异步操作时，Swift 5.5 引入了 async 和 await 关键字，允许你编写更加同步化的异步代码。同时，结合 throws，你可以在异步函数中更自然地处理错误。

示例：

 func fetchData(from url: String) async throws -> Data {
    guard let url = URL(string: url) else {
        throw NetworkError.badURL
    }
 
    let (data, response) = try await URLSession.shared.data(from: url)
     
    guard (response as? HTTPURLResponse)?.statusCode == 200 else {
        throw NetworkError.responseUnsuccessful
    }
    return data
 }
 
 Task {
    do {
        let data = try await fetchData(from: "https://example.com")
        print("Data received: (data)")
    } catch {
        print("Error fetching data: (error)")
    }
 }

在这个例子中，fetchData(from:) 是一个异步抛出错误的函数，结合 async 和 throws 使得代码既能处理异步操作，又能进行错误处理。

总结

深入掌握 Swift 中的 throws 和 throw，并了解如何在不同场景中合理使用这些功能，可以显著提升你的代码质量和可维护性。关注错误处理的最佳实践、灵活使用 rethrows、Result 类型以及新引入的 async/await 功能，能让你应对复杂的错误场景时更加得心应手。在编写测试代码时，特别要关注错误处理的测试，确保所有边界情况都得到了妥善的处理。通过这些深入理解和技巧的应用，你可以构建更加健壮和稳定的 Swift 应用程序。

Swift 异常处理以及注意事项

throws

throw

rethrows