Swift循环中实现异步调用顺序执行的方案咨询

你的崩溃和i从未为0的根源在于同步循环和异步回调的执行时机不匹配：

• for循环是同步执行的，会在极短时间内遍历完整个commentReplyArray，此时变量i已经走到了数组的长度值（比如数组有3个元素，循环结束后i=3）。
• 而fetchDetailsAboutCommentReply的回调是异步触发的，当回调执行时，i已经不是循环时的那个值了，这就导致你用index + i + 1计算插入位置时，会超出dataSource的范围，直接引发崩溃。

另外，你的代码是并行发起所有异步请求，无法保证顺序执行，这也会导致dataSource里的元素顺序和原数组不一致。

下面提供两种可靠的实现方式，从兼容性和简洁性两个角度出发：

方案1：递归顺序处理（兼容所有Swift版本） #

通过递归函数逐个处理数组元素，确保前一个元素的所有异步操作完成后，再处理下一个：

self.dataAccessService.fetchRepliesByCommentId(completionHandler: { [weak self] commentReplyArray in
    guard let self = self else { return }
    var currentIndex = 0
    let totalCount = commentReplyArray.count
    var ips = [IndexPath]()
    
    // 递归处理函数
    func processNextReply() {
        guard currentIndex < totalCount else {
            // 所有元素处理完成，通知代理
            self.delegate?.didLoadReplies(dataSource: self.dataSource, ips: ips)
            return
        }
        
        let commentReply = commentReplyArray[currentIndex]
        self.fetchDetailsAboutCommentReply(commentReplyObject: commentReply) { commentItem in
            commentItem.commentObject = commentReply
            // 计算当前插入位置：index + currentIndex + 1（因为currentIndex从0开始）
            let insertPosition = index + currentIndex + 1
            self.dataSource.insert(commentItem, at: insertPosition)
            ips.append(IndexPath(row: insertPosition, section: 0))
            
            // 处理下一个元素
            currentIndex += 1
            processNextReply()
        }
    }
    
    // 启动递归处理
    processNextReply()
}, commentId: commentItem.commentObject.id)

这个方案的核心是用currentIndex追踪当前处理的元素，每次回调完成后才递增索引并处理下一个，完美保证顺序，也不会出现i值混乱的问题。

方案2：用Async/Await（Swift 5.5+，推荐） #

如果你的项目支持Swift 5.5及以上，用async/await可以让异步代码更简洁易读，天然支持顺序执行：

首先把你的异步函数改成支持async的版本：

// 改造fetchRepliesByCommentId为async函数
extension DataAccessService {
    func fetchRepliesByCommentId(commentId: String) async -> [CommentReply] {
        return await withCheckedContinuation { continuation in
            self.fetchRepliesByCommentId(completionHandler: continuation.resume(returning:), commentId: commentId)
        }
    }
    
    // 改造fetchDetailsAboutCommentReply为async函数
    func fetchDetailsAboutCommentReply(commentReplyObject: CommentReply) async -> CommentItem {
        return await withCheckedContinuation { continuation in
            self.fetchDetailsAboutCommentReply(commentReplyObject: commentReplyObject, completionHandler: continuation.resume(returning:))
        }
    }
}

然后在调用处用async/await顺序处理：

Task { [weak self] in
    guard let self = self else { return }
    do {
        let commentReplyArray = try await self.dataAccessService.fetchRepliesByCommentId(commentId: commentItem.commentObject.id)
        var ips = [IndexPath]()
        
        for (currentIndex, commentReply) in commentReplyArray.enumerated() {
            let commentItem = try await self.fetchDetailsAboutCommentReply(commentReplyObject: commentReply)
            commentItem.commentObject = commentReply
            let insertPosition = index + currentIndex + 1
            self.dataSource.insert(commentItem, at: insertPosition)
            ips.append(IndexPath(row: insertPosition, section: 0))
        }
        
        // 所有元素处理完成，通知代理（回到主线程，因为UI操作必须在主线程）
        await MainActor.run {
            self.delegate?.didLoadReplies(dataSource: self.dataSource, ips: ips)
        }
    } catch {
        // 处理错误，比如网络请求失败
        print("Failed to load replies: \(error)")
    }
}

这种方式完全避免了回调地狱，代码逻辑清晰，而且enumerated()能直接拿到正确的当前索引，不会出现之前的i值混乱问题。

• 尽量避免在异步回调中频繁修改dataSource并通知UI，最好先把所有CommentItem收集到一个临时数组里，最后一次性插入到dataSource中，这样能减少UI刷新的次数，提升性能。
• 注意使用[weak self]避免循环引用，防止内存泄漏。

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