带闭包的For循环中如何按顺序串行执行异步obj.f方法？

原有实现存在几个可优化点：依赖全局索引变量、隐式强制解包obj存在崩溃风险、执行状态维护散落在全局作用域，不易调试和扩展。以下是不同场景下的更优实现：

方案1：Swift 5.5+ 推荐：async/await 包装回调（最简洁优雅） #

首先把原有基于回调的SomeObj初始化逻辑包装为异步函数，彻底避免手动维护索引、隐式解包等问题：

// 第一步：将回调API封装为async方法
func processElement<T>(_ element: T) async throws {
    try await withCheckedThrowingContinuation { continuation in
        let obj = SomeObj(handler: { result in
            // 假设handler会返回处理结果/错误，按实际情况调整
            if let error = result.error {
                continuation.resume(throwing: error)
            } else {
                continuation.resume()
            }
        })
        obj.f(element)
    }
}

// 第二步：直接循环串行执行即可
let arr = [元素数组]
func serialProcess() async {
    for element in arr {
        do {
            try await processElement(element)
        } catch {
            // 处理单元素执行错误，可选择终止循环或者跳过继续
            print("元素\(element)处理失败：\(error)")
            // break // 需要终止就打开注释
        }
    }
}

这个方案完全不需要手动维护索引、不需要持有全局obj，完全符合API串行要求，也不会阻塞当前线程，语法简洁易维护。

方案2：兼容旧版本Swift：自定义异步Operation + OperationQueue #

如果需要支持低于iOS 15/macOS 12的系统，使用OperationQueue控制并发数为1，自动实现串行执行：

// 自定义异步Operation
class ProcessOperation<T>: Operation {
    private let element: T
    private var taskFinished = false
    
    override var isFinished: Bool { taskFinished }
    override var isAsynchronous: Bool { true }
    
    init(element: T) {
        self.element = element
        super.init()
    }
    
    override func start() {
        guard !isCancelled else {
            taskFinished = true
            return
        }
        let obj = SomeObj(handler: { [weak self] _ in
            guard let self = self else { return }
            // 标记Operation完成，队列自动执行下一个
            self.willChangeValue(for: \.isFinished)
            self.taskFinished = true
            self.didChangeValue(for: \.isFinished)
        })
        obj.f(element)
    }
}

// 使用
let arr = [元素数组]
let queue = OperationQueue()
queue.maxConcurrentOperationCount = 1 // 强制串行
arr.forEach { element in
    queue.addOperation(ProcessOperation(element: element))
}
// 可以监听队列所有任务完成
queue.addOperation {
    print("所有元素处理完成")
}

这个方案可以自动管理任务调度，支持取消任务、添加依赖等扩展能力，不需要手动维护执行状态。

方案3：轻量递归闭包方案（无外部依赖） #

如果不想引入OperationQueue的额外开销，用递归闭包的方式替换原有的全局索引方案，避免全局变量污染：

let arr = [元素数组]
func serialProcess(index: Int = 0) {
    guard index < arr.count else {
        print("所有元素处理完成")
        return
    }
    let obj = SomeObj(handler: { _ in
        // 当前元素处理完成，递归处理下一个
        serialProcess(index: index + 1)
    })
    obj.f(arr[index])
}
// 启动执行
serialProcess()

这个方案比原有实现更简洁，没有全局变量和隐式解包的问题，逻辑清晰。

内容的提问来源于stack exchange，提问作者swifter