错误处理

是什么，为什么存在

错误处理用于表示操作没有产生承诺的结果，并把失败原因交给能够决定下一步的代码。Swift 的错误是普通值：任何遵循 Error 协议的类型都可以被抛出。枚举特别适合表示一组有限的失败类别，关联值则可以携带导致恢复决策所需的上下文。

可抛出函数（ throwing function ）在签名中写出 throws。调用点必须写 try，让控制流可能提前离开这件事在代码审查时可见。错误从当前作用域继续交给调用方的过程叫作 错误传播（error propagation） 。

错误与可选值解决的问题不同。可选值表示“可能没有值”，但不解释原因；错误适合调用方需要区分输入无效、资源不可用或权限不足等情况。断言与前置条件则用于程序员违约或状态不变量被破坏，不能代替可恢复错误。

你会在解析、文件系统、网络、持久化和异步 API 中遇到错误处理。关键设计问题不是“在哪里加 catch”，而是哪个边界有足够信息来重试、降级、提示用户或把失败转换成领域错误。

工作原理

一个错误路径包含四个动作：定义错误值、用 throw 发出失败、在调用点用 try 标记可能的控制转移，以及处理或继续传播。throw 会立即离开当前正常路径；它后面的语句不会执行。抛出函数可以返回值，但一次调用只会返回值或抛出错误，不会同时发生两者。

常见的错误枚举把稳定类别放在 case 中，把动态信息放在关联值中。例如，invalidCoupon(code:) 比一个字符串错误更适合程序化处理，因为调用方可以穷尽匹配类别，同时保留具体优惠码用于安全的用户提示。

Swift 提供四种调用形式：

1. try 保留错误，让当前作用域捕获或继续传播。
2. try? 把成功值变成可选值，并在抛错时得到 nil。
3. try! 断言不会抛错；如果断言错误，程序会触发运行时错误。
4. Result<Success, Failure> 把成功或失败保存为一个值，适合缓存、队列或仍使用完成回调的接口。

按语义选择表示

同一个失败不应该同时被包装成可选值、错误和布尔标记。选择一种主要表示，让调用方从类型和调用语法中看出需要处理什么；只有跨越存储或回调边界时再做一次明确转换。

表格描述的是 API 契约，不是错误严重程度。同一个“找不到记录”在搜索接口中可以是 nil，在按主键更新的接口中则可能是错误；决定因素是调用方承诺与恢复需求。

do–catch 按源码顺序选择第一个匹配的 catch。模式可以匹配具体错误 case、绑定关联值、使用 where 增加条件，或用无模式的 catch 接住剩余错误。普通 throws 等价于 throws(any Error)，因此通常需要最终兜底分支。

Swift 6 的类型化 throws（ typed throws ）把具体失败类型写成 throws(MyError)。编译器会拒绝函数体抛出其他类型，并能在调用链中保留这个类型。具体错误类型是 API 契约的一部分；无类型限定的 throws 则允许实现与依赖在以后增加新的错误类型。

处理位置决定抽象边界。低层函数应该提供足以诊断的错误，高层边界可以恢复，或把实现细节转换为领域错误。转换时可以通过关联值保留底层原因，这是一种 错误包装（error wrapping） ；不要只留下失去上下文的通用字符串。

捕获位置就是恢复位置

捕获并不等于处理。只打印错误后返回一个正常值，通常会让失败从类型系统中消失；如果本层无法采取不同动作，应继续传播，让更高层决定。

合适的恢复动作必须改变结果：重试一个被判定为瞬时的操作、改用明确的后备数据、提示用户修正输入，或把技术错误转换成稳定的领域失败。单纯记录日志不改变失败状态，因此通常还要重新抛出。

错误可以经过多个不捕获的中间函数。这样不会降低健壮性，反而能避免每层复制相同的 do–catch。边界越少，错误转换规则和可观测性策略越容易保持一致。

抛出初始化器使用同一套规则：初始化完成前发现输入不满足条件，就抛错而不是构造一个部分有效的实例。调用方仍然通过 try 处理，失败时不会得到该实例。

示例

定义、抛出并捕获领域错误

第一个例子用枚举区分空购物车与无效优惠码。checkoutTotal 使用普通 throws，所以调用方最后保留兜底 catch，以应对签名允许的任意 Error 值。

每轮循环中的调用要么打印总价，要么转入一个匹配的处理分支。空购物车分支不需要错误对象，优惠码分支则绑定关联值。最后的 catch 不是装饰；它对应普通 throws 暴露的开放错误集合。

真正的业务代码通常不会在低层直接打印。界面层可以把 emptyCart 转成操作提示，把 invalidCoupon 标记到输入字段；服务层也可以继续 throw，把决定权留给更了解用户操作的调用方。

用类型化 throws 封闭失败集合

类型化 throws 让 parseQuantity 只能抛出 QuantityError。无模式的 catch 中，error 保持具体枚举类型，因此内部的 switch 必须穷尽所有 case；以后新增 case 时，编译器会指出需要同步更新的处理代码。

// # not executed here: Swift toolchain is not installed.
enum QuantityError: Error {
    case empty
    case notANumber(String)
    case outsideRange(Int)
}

func parseQuantity(_ text: String) throws(QuantityError) -> Int {
    guard !text.isEmpty else { throw .empty }
    guard let value = Int(text) else { throw .notANumber(text) }
    guard 1...20 ~= value else { throw .outsideRange(value) }
    return value
}

for input in ["3", "", "many", "25"] {
    do {
        print("quantity: \(try parseQuantity(input))")
    } catch {
        switch error {
        case .empty:
            print("quantity is empty")
        case .notANumber(let text):
            print("not a number: \(text)")
        case .outsideRange(let value):
            print("outside range: \(value)")
        }
    }
}

Not executed here: Swift toolchain is not installed.

短写法 throw .empty 成立，是因为函数签名已经给出错误类型。具体类型适合失败集合由当前模块完整控制的函数；如果函数直接传播多个依赖的错误，强行压成一个枚举可能带来大量没有恢复价值的包装代码。

do throws(QuantityError) { ... } 也可以显式限制一个 do 块的错误类型。单一具体错误类型通常能被推断出来，但在公共函数签名中写明它，能让调用方直接看到契约。

把失败保存为 Result

Result 类型（ result type ）是带有 .success 与 .failure 两个 case 的枚举。这里的函数把一次库存预留保存成值；调用方可以稍后 switch，而不必在产生结果的同一调用栈中立刻处理。

// # not executed here: Swift toolchain is not installed.
enum StockError: Error {
    case invalidRequest
    case insufficient(available: Int)
}

func reserve(stock: Int, requested: Int) throws(StockError) -> Int {
    guard requested > 0 else { throw .invalidRequest }
    guard requested <= stock else { throw .insufficient(available: stock) }
    return stock - requested
}

func reservation(stock: Int, requested: Int) -> Result<Int, StockError> {
    do {
        return .success(try reserve(stock: stock, requested: requested))
    } catch {
        return .failure(error)
    }
}

for requested in [2, 7] {
    switch reservation(stock: 5, requested: requested) {
    case .success(let remaining):
        print("remaining: \(remaining)")
    case .failure(.invalidRequest):
        print("invalid request")
    case .failure(.insufficient(let available)):
        print("only \(available) available")
    }
}

Not executed here: Swift toolchain is not installed.

Result.get() 可以把保存的失败重新抛出，map 只转换成功值，mapError 只转换失败值。它们适合在值管道中组合，但不会自动决定哪些错误应该恢复，也不会替代异步函数原生的 async throws。

新写的异步 Swift API 通常直接返回值并使用 async throws。只有结果需要存储、作为集合元素传递，或必须适配回调协议时，显式 Result 才提供额外价值。

用 rethrows 保留调用方能力

rethrows 表示函数只能在传入的函数参数抛错时抛错，不能自行产生新的错误。audited 的非抛出闭包调用不需要 try；传入抛出闭包时，错误穿过包装函数。defer 在成功返回或抛错离开当前作用域前都会运行。

// # not executed here: Swift toolchain is not installed.
enum ExportError: Error {
    case empty
}

func audited<T>(_ operation: () throws -> T) rethrows -> T {
    print("begin")
    defer { print("end") }
    return try operation()
}

func export(rowCount: Int) throws(ExportError) -> String {
    guard rowCount > 0 else { throw .empty }
    return "report.csv"
}

let cached = audited { "cached.csv" }
print(cached)

do {
    print(try audited { try export(rowCount: 0) })
} catch ExportError.empty {
    print("empty export")
} catch {
    print("unexpected error: \(error)")
}

Not executed here: Swift toolchain is not installed.

defer 适合释放锁、关闭自行管理的句柄或恢复临时状态，但它不会回滚已经提交的业务副作用。如果包装器本身可能因审计写入失败而抛出新错误，它就不能声明为 rethrows，而应该使用普通或类型化 throws 明确扩大失败集合。

陷阱

修复： 只有失败原因无关紧要且 nil 语义明确时才使用 try?。在数据边界使用 do–catch 记录获准的诊断信息，再传播或转换错误；不要默认记录完整输入或敏感关联值。

修复： 使用普通 try 并处理或传播错误。只有失败确实表示不可继续的程序缺陷，而且该不变量由测试和封装共同保证时，才考虑 try!；即使如此，也应把断言限制在最小边界。

修复： 具体模式写在前面，最后为开放错误集合提供兜底。失败集合确实封闭时使用类型化 throws，并用穷尽 switch 让新增 case 变成编译错误。

修复： 只在抽象边界转换错误，并保留调用方做恢复决策所需的类别与上下文。需要诊断底层原因时，把原错误存入关联值，同时让日志策略决定哪些数据可以输出。

修复： 在不可逆副作用之前完成校验，使用具备原子性的存储 API，或为分步操作设计补偿路径。测试应在每个可能抛错的步骤注入失败并检查最终状态，而不只是断言收到某个错误。

延伸阅读

• Swift 编程语言：错误处理
• Swift 编程语言：抛出函数与方法
• Swift Evolution SE-0413：类型化 throws
• Apple 开发者文档：Result