如何处理异步URLRequest完成？函数内创建请求无法返回响应的问题

嘿，这个问题在异步编程里太常见了——毕竟网络请求是需要时间的，函数肯定会先返回，等响应回来的时候早就错过了直接返回的时机。别担心，咱们有好几种靠谱的办法来处理这种情况，看你用的Swift版本和项目场景来选：

这是传统异步编程里的经典操作，核心思路就是：把你想在请求完成后执行的逻辑，打包成一个闭包参数传给函数，等异步请求结束后再调用这个闭包。

举个实际代码例子：

func fetchRemoteData(completion: @escaping (Result<[String: Any], Error>) -> Void) {
    // 先构造请求
    guard let targetUrl = URL(string: "https://your-api-endpoint.com/data") else {
        completion(.failure(NSError(domain: "InvalidURL", code: 0, userInfo: ["message": "URL格式错误"])))
        return
    }
    let request = URLRequest(url: targetUrl)
    
    // 发起异步请求
    URLSession.shared.dataTask(with: request) { data, response, error in
        // 先处理错误
        if let reqError = error {
            completion(.failure(reqError))
            return
        }
        
        // 确保拿到数据
        guard let responseData = data else {
            completion(.failure(NSError(domain: "EmptyData", code: 1, userInfo: ["message": "响应无数据"])))
            return
        }
        
        // 解析JSON
        do {
            if let jsonResult = try JSONSerialization.jsonObject(with: responseData, options: []) as? [String: Any] {
                completion(.success(jsonResult))
            } else {
                completion(.failure(NSError(domain: "InvalidJSON", code: 2, userInfo: ["message": "JSON格式不匹配"])))
            }
        } catch let parseError {
            completion(.failure(parseError))
        }
    }.resume() // 别忘了启动任务！
}

// 调用的时候这样用：
fetchRemoteData { result in
    switch result {
    case .success(let json):
        // 这里就是请求完成后要执行的逻辑，比如更新UI、处理数据
        print("成功拿到JSON: \(json)")
    case .failure(let error):
        // 处理各种错误情况
        print("请求出错了: \(error.localizedDescription)")
    }
}

关键点：闭包要加@escaping标记，因为它会在函数返回之后才被调用；用Result类型可以统一处理成功和失败的情况，让代码逻辑更清晰。

如果你用的是Swift 5.5及以上的版本，强烈推荐用这个方案——它能让异步代码看起来像同步代码一样线性，完全不用嵌套闭包，可读性拉满。

代码示例：

// 函数标记为async throws，表示它是异步的，且可能抛出错误
func fetchRemoteData() async throws -> [String: Any] {
    guard let targetUrl = URL(string: "https://your-api-endpoint.com/data") else {
        throw NSError(domain: "InvalidURL", code: 0, userInfo: ["message": "URL格式错误"])
    }
    let request = URLRequest(url: targetUrl)
    
    // 用await等待请求完成，拿到数据和响应
    let (responseData, urlResponse) = try await URLSession.shared.data(for: request)
    
    // 验证响应状态码
    guard let httpResponse = urlResponse as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        throw NSError(domain: "InvalidResponse", code: 1, userInfo: ["message": "响应状态码错误"])
    }
    
    // 解析JSON
    guard let jsonResult = try JSONSerialization.jsonObject(with: responseData, options: []) as? [String: Any] else {
        throw NSError(domain: "InvalidJSON", code: 2, userInfo: ["message": "JSON格式不匹配"])
    }
    
    return jsonResult
}

// 调用时要在异步上下文里，比如用Task包裹
Task {
    do {
        let json = try await fetchRemoteData()
        // 请求完成后处理逻辑
        print("成功拿到JSON: \(json)")
    } catch let error {
        // 捕获错误
        print("请求出错了: \(error.localizedDescription)")
    }
}

关键点：await会暂停当前任务，直到请求完成，不会阻塞主线程；整个代码结构和同步代码几乎一样，不用再写嵌套的闭包回调。

如果你的项目用了SwiftUI或者响应式编程的思路，Combine框架会是个很好的选择——它把请求转换成一个「发布者（Publisher）」，你可以通过订阅来监听结果，还能链式处理数据转换、线程切换等操作。

代码示例：

import Combine

func fetchRemoteData() -> AnyPublisher<[String: Any], Error> {
    guard let targetUrl = URL(string: "https://your-api-endpoint.com/data") else {
        // 如果URL无效，返回一个失败的发布者
        return Fail(error: NSError(domain: "InvalidURL", code: 0, userInfo: ["message": "URL格式错误"]))
            .eraseToAnyPublisher()
    }
    let request = URLRequest(url: targetUrl)
    
    // 链式处理请求、验证响应、解析JSON
    return URLSession.shared.dataTaskPublisher(for: request)
        .tryMap { data, response in
            // 验证响应状态码
            guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
                throw NSError(domain: "InvalidResponse", code: 1, userInfo: ["message": "响应状态码错误"])
            }
            return data
        }
        .decode(type: [String: Any].self, decoder: JSONDecoder())
        .eraseToAnyPublisher()
}

// 调用并订阅结果
var cancellables = Set<AnyCancellable>()

fetchRemoteData()
    .receive(on: DispatchQueue.main) // 切换到主线程，方便更新UI
    .sink(
        receiveCompletion: { completion in
            switch completion {
            case .finished:
                print("请求完成")
            case .failure(let error):
                print("请求出错: \(error.localizedDescription)")
            }
        },
        receiveValue: { json in
            // 处理拿到的JSON数据
            print("成功拿到JSON: \(json)")
        }
    )
    .store(in: &cancellables) // 把订阅存起来，防止被提前释放

关键点：用sink来订阅发布者的结果；一定要把订阅对象存在Set<AnyCancellable>里，否则订阅会被销毁，无法收到响应。

最后给你个选择建议：

• 要是项目需要兼容Swift 5.5以下的版本，选完成闭包；
• 要是用的是新版本Swift，优先用Async/Await，代码最简洁；
• 要是SwiftUI项目或者响应式场景，选Combine更贴合生态。

内容的提问来源于stack exchange，提问作者Dmytrii G.