try/await与错误抛出

Swift的async/await不仅简化了异步代码的编写，还通过与错误抛出机制（throws和try）的深度集成，提供了一种优雅的方式来处理异步任务中的异常。相比传统闭包的分散错误检查，try/await将错误管理集中化，提升了代码的可读性和健壮性。本节将详细讲解try/await的基本用法、在异步函数中的错误抛出机制，以及在实际开发中的应用场景，帮助你全面掌握这一现代并发特性。

基本概念

在Swift中，错误处理通过throws和try实现，async/await将其扩展到异步场景：

  • throws：标记函数可能抛出错误，调用者需处理。
  • try：在调用可能抛出错误的函数时使用，表示潜在异常。
  • await：等待异步任务完成，与try结合处理异步错误。

当一个异步函数可能失败时，它会被标记为async throws，调用时需要try await：

func fetchData() async throws -> String {
    try await Task.sleep(nanoseconds: 1_000_000_000) // 模拟延迟
    if Bool.random() { throw FetchError.networkFailure }
    return "数据成功"
}

enum FetchError: Error {
    case networkFailure
}

调用时用do/catch捕获错误：

Task {
    do {
        let result = try await fetchData()
        print(result)
    } catch {
        print("错误：\(error)")
    }
}

这与同步错误处理的语法一致，只是多了await来等待异步结果。

错误抛出的机制

async/await的错误处理构建在Swift的异常系统中，异步函数抛出错误时：

  • 挂起任务：await暂停当前执行，等待结果或错误。
  • 传播错误：错误通过调用栈向上抛出，直到被捕获。
  • 底层支持：Swift运行时与GCD协作，确保错误在正确的线程上下文中传递。

例如，一个完整的错误抛出流程：

func fetchUser() async throws -> String {
    let (data, _) = try await URLSession.shared.data(from: URL(string: "https://api.example.com/user")!)
    guard !data.isEmpty else { throw FetchError.emptyResponse }
    return String(data: data, encoding: .utf8) ?? ""
}

Task {
    do {
        let user = try await fetchUser()
        print("用户：\(user)")
    } catch FetchError.emptyResponse {
        print("响应为空")
    } catch {
        print("未知错误：\(error)")
    }
}
  • URLSession可能抛出网络错误。
  • 自定义条件（如空数据）抛出特定错误。
  • catch块分情况处理。

与闭包对比

传统闭包错误处理分散且重复，例如：

func fetchUser(completion: @escaping (Result<String, Error>) -> Void) {
    URLSession.shared.dataTask(with: URL(string: "https://api.example.com/user")!) { data, _, error in
        if let error = error {
            completion(.failure(error))
            return
        }
        guard let data = data, !data.isEmpty else {
            completion(.failure(FetchError.emptyResponse))
            return
        }
        let result = String(data: data, encoding: .utf8) ?? ""
        completion(.success(result))
    }.resume()
}

fetchUser { result in
    switch result {
    case .success(let user): print("用户：\(user)")
    case .failure(let error): print("错误：\(error)")
    }
}

相比之下，try/await：

  • 将错误检查集中到do/catch。
  • 无需手动封装Result，直接返回结果或抛出错误。

使用场景

try/await适用于所有可能失败的异步任务，以下是几个典型场景：

1. 网络请求

处理网络异常：

func fetchPost(id: String) async throws -> Post {
    let url = URL(string: "https://api.example.com/post/\(id)")!
    let (data, response) = try await URLSession.shared.data(from: url)
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        throw FetchError.invalidStatus
    }
    return try JSONDecoder().decode(Post.self, from: data)
}

Task {
    do {
        let post = try await fetchPost(id: "1")
        print("帖子标题：\(post.title)")
    } catch FetchError.invalidStatus {
        print("无效状态码")
    } catch {
        print("请求失败：\(error)")
    }
}

2. 文件操作

处理文件访问错误：

func readConfig(at path: String) async throws -> String {
    let url = URL(fileURLWithPath: path)
    guard FileManager.default.fileExists(atPath: path) else {
        throw FileError.notFound
    }
    let data = try await FileManager.default.contents(atPath: path)!
    return String(data: data, encoding: .utf8)!
}

enum FileError: Error {
    case notFound
}

Task {
    do {
        let config = try await readConfig(at: "config.txt")
        print("配置：\(config)")
    } catch FileError.notFound {
        print("文件未找到")
    } catch {
        print("读取失败：\(error)")
    }
}

3. 多任务依赖

顺序执行并统一处理错误：

func fetchProfile() async throws -> (String, [Post]) {
    let user = try await fetchUser()
    let posts = try await fetchPost(id: user) // 假设user是ID
    return (user, posts)
}

Task {
    do {
        let (user, posts) = try await fetchProfile()
        print("用户：\(user), 帖子数：\(posts.count)")
    } catch {
        print("加载失败：\(error)")
    }
}

最佳实践

  1. 定义具体错误类型
    使用枚举（如FetchError）描述特定失败原因，便于针对性处理。

  2. 避免过度捕获
    只捕获需要处理的错误，未处理的让上层调用者接管：

    func innerTask() async throws -> String {
    try await fetchData()
}

  3. 结合@MainActor
    确保错误处理后UI更新安全：

    @MainActor
func showError(_ error: Error) {
    alertLabel.text = "错误：\(error)"
}

  4. 日志记录
    在catch中记录错误，便于调试。

小结

try/await将Swift的错误处理机制无缝扩展到异步编程，提供了集中化、可预测的异常管理方式。通过与throws的结合，它取代了闭包的分散检查，使代码更简洁、更健壮。本节通过网络请求和文件操作等场景展示了其用法和优势，为你在异步任务中有效处理错误奠定了基础。下一节将探讨异步任务的具体实践，带你深入应用这些知识。

内容说明

  • 结构：从概念到机制，再到场景和实践，最后总结。
  • 代码：包含网络、文件等多场景示例，突出try/await的实用性。
  • 语气：讲解性且指导性，适合技术书籍的深入章节。
  • 衔接：承接第四章（async/await基础），预告后续（实战案例）。
Last Updated::