RxSwift问题：合并Completable数组及序列执行报错排查

嘿，我来帮你解决这两个RxSwift的问题！

在RxSwift里，合并Completable数组主要有两种常用方式，取决于你需要依次执行还是并行执行所有Completable：

方式一：依次执行（前一个完成才启动下一个） #

用Completable.concat(_:)方法，它会严格按照数组顺序逐个执行Completable。只有当所有Completable都成功完成时，合并后的Completable才会触发onCompleted；只要其中一个任务失败，整个序列会立即终止并触发onError。

示例代码：

let completable1 = Completable.create { observer in
    // 模拟异步任务1
    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
        observer(.completed)
    }
    return Disposables.create()
}

let completable2 = Completable.create { observer in
    // 模拟异步任务2
    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
        observer(.completed)
    }
    return Disposables.create()
}

let completables = [completable1, completable2]

// 合并为单个Completable并订阅
Completable.concat(completables)
    .subscribe(onCompleted: {
        print("所有任务都按顺序完成了！")
    }, onError: { error in
        print("某个任务执行失败：\(error.localizedDescription)")
    })
    .disposed(by: disposeBag)

方式二：并行执行（同时启动所有任务） #

用Completable.merge(_:)方法，它会同时启动数组内的所有Completable。只有当全部任务都成功完成时，合并后的Completable才会触发onCompleted；只要有一个任务失败，整个序列会立即终止并触发onError。

示例代码：

Completable.merge(completables)
    .subscribe(onCompleted: {
        print("所有并行任务都完成了！")
    }, onError: { error in
        print("某个并行任务执行失败：\(error.localizedDescription)")
    })
    .disposed(by: disposeBag)

注意：如果你的场景需要“只要有一个任务成功就返回成功”，Completable并不适合（它只关注完成/失败状态，没有返回值），这种情况可以考虑将Completable转为Maybe或Observable后再处理。

这类问题通常和序列链式逻辑、类型转换、订阅生命周期这几个点有关，我列举几个最容易踩坑的场景，你可以对照自己的代码排查：

错误场景1：用forEach循环调用Rx方法，未使用Rx链式序列保证顺序 #

很多人会写出这样的错误代码：

let values = [1, 2, 3]
values.forEach { value in
    // processValue是返回Single的方法
    processValue(value)
        .flatMapCompletable { result in
            // saveResult是返回Completable的方法
            return saveResult(result)
        }
        .subscribe()
        .disposed(by: disposeBag)
}

问题：这种写法会同时启动所有任务，无法保证“依次执行”；且某个任务失败时，其他任务仍会继续执行，不符合预期；如果disposeBag提前释放，还会导致订阅被意外取消。

修正方法：用Observable.from(values)配合concatMap来严格保证顺序执行：

Observable.from(values)
    .concatMap { value in
        // 先执行Single，再链式调用Completable，转成Observable适配concatMap
        processValue(value)
            .flatMapCompletable { result in
                saveResult(result)
            }
            .asObservable()
    }
    .ignoreElements() // 忽略所有元素，只保留完成/失败状态
    .asCompletable()
    .subscribe(onCompleted: {
        print("所有值都按顺序处理完成！")
    }, onError: { error in
        print("处理某个值时失败：\(error.localizedDescription)")
    })
    .disposed(by: disposeBag)

错误场景2：flatMap使用不当，类型转换不匹配 #

比如你在Single后用了普通flatMap，但闭包里返回的是Completable，导致类型不匹配报错：

// 错误示例：flatMap要求返回Observable类型，但这里返回Completable
processValue(value)
    .flatMap { result in
        return saveResult(result) // saveResult返回Completable，类型不兼容
    }

修正方法：改用flatMapCompletable，它专门用于处理返回Completable的场景：

processValue(value)
    .flatMapCompletable { result in
        saveResult(result)
    }

错误场景3：未正确管理Dispose Bag #

如果订阅没有添加到disposeBag，或者disposeBag在任务完成前就被释放，会导致任务被取消，甚至出现内存泄漏或野指针报错。

修正方法：确保所有订阅都调用.disposed(by: disposeBag)，且disposeBag的生命周期要长于任务执行时间（比如作为ViewController的属性，而非局部变量）。

错误场景4：任务内部错误未正确传递 #

比如在Completable的create闭包里吞掉了错误，导致订阅时无法收到错误信息，看起来像是“报错”但实际错误被隐藏了：

// 错误示例：吞掉了错误，未传递给观察者
let saveResult: (String) -> Completable = { result in
    return Completable.create { observer in
        try? someThrowingOperation(result)
        observer(.completed) // 即使出错也标记完成
        return Disposables.create()
    }
}

修正方法：在闭包里正确传递错误：

let saveResult: (String) -> Completable = { result in
    return Completable.create { observer in
        do {
            try someThrowingOperation(result)
            observer(.completed)
        } catch {
            observer(.error(error)) // 必须将错误传递给观察者
        }
        return Disposables.create()
    }
}

如果你的代码不属于以上场景，可以把具体错误信息和代码片段贴出来，我再帮你精准定位问题！

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