如何用RxSwift/ReactiveSwift将A数组转换为含已下载UIImage的B数组？

刚好我之前在项目里处理过类似的需求，给你分享几个用RxSwift和ReactiveSwift实现的靠谱方案，都是经过验证的：

核心思路是把单个A对象的转换（包含两张图片的下载）封装成一个Observable<B>，再批量处理数组里的所有A，最后合并成[B]的结果流。

1. 先实现图片下载的基础Observable #

首先需要一个通用的图片下载方法，支持错误处理（比如下载失败时返回nil，避免整个流中断）：

import RxSwift
import RxCocoa

func downloadImage(url: URL) -> Observable<UIImage?> {
    return URLSession.shared.rx.data(request: URLRequest(url: url))
        .map { data in UIImage(data: data) }
        .catch { _ in
            // 下载失败时返回nil，也可以替换成默认占位图
            return Observable.just(nil)
        }
}

2. 单个A转B的Observable #

利用zip操作符同时发起图片和缩略图的下载请求，等两个请求都完成后再组装成B对象：

func convertAtoB(_ a: A) -> Observable<B> {
    let imageObservable = downloadImage(url: a.imageURL)
    let thumbnailObservable = downloadImage(url: a.thumbnailURL)
    
    return Observable.zip(imageObservable, thumbnailObservable) { image, thumbnail in
        B(name: a.name, image: image, thumbnail: thumbnail)
    }
}

3. 批量转换数组 #

把[A]转换成Observable<[B]>，这里可以通过flatMap控制并发下载的数量，避免同时发起太多请求导致性能问题：

func convertAArrayToBArray(_ array: [A]) -> Observable<[B]> {
    return Observable.from(array)
        // 限制同时处理3个请求，可根据实际需求调整
        .flatMap(maxConcurrent: 3) { self.convertAtoB($0) }
        .toArray() // 把所有B对象收集成数组
}

使用示例 #

let disposeBag = DisposeBag()
let aArray: [A] = [/* 你的A对象数组 */]

convertAArrayToBArray(aArray)
    .subscribe(onNext: { bArray in
        // 拿到转换后的B数组，做后续处理
        print("转换完成，共\(bArray.count)个B对象")
    }, onError: { error in
        // 这里的错误只有在toArray等环节出错才会触发，单个图片下载失败不会走到这里
        print("转换过程出错：\(error)")
    })
    .disposed(by: disposeBag)

思路和RxSwift类似，只是用SignalProducer替代Observable，操作符的用法略有差异。

1. 图片下载的基础SignalProducer #

import ReactiveSwift

func downloadImageProducer(url: URL) -> SignalProducer<UIImage?, Never> {
    return URLSession.shared.reactive.data(with: URLRequest(url: url))
        .map { data, _ in UIImage(data: data) }
        .flatMapError { _ in
            // 下载失败返回nil或占位图
            return SignalProducer(value: nil)
        }
}

2. 单个A转B的SignalProducer #

用zip合并两个下载流，组装成B对象：

func convertAtoB(_ a: A) -> SignalProducer<B, Never> {
    let imageProducer = downloadImageProducer(url: a.imageURL)
    let thumbnailProducer = downloadImageProducer(url: a.thumbnailURL)
    
    return SignalProducer.zip(imageProducer, thumbnailProducer) { image, thumbnail in
        B(name: a.name, image: image, thumbnail: thumbnail)
    }
}

3. 批量转换数组 #

通过flatten控制并发策略，最后用collect收集成数组：

func convertAArrayToBArray(_ array: [A]) -> SignalProducer<[B], Never> {
    return SignalProducer(array)
        // .merge表示并发处理，.concat表示顺序处理；也可以用.flatten(.merge(maxConcurrent: 3))控制并发数
        .flatMap(.merge, transform: convertAtoB)
        .collect()
}

使用示例 #

let aArray: [A] = [/* 你的A对象数组 */]

convertAArrayToBArray(aArray)
    .startWithResult { result in
        switch result {
        case .success(let bArray):
            print("转换完成，共\(bArray.count)个B对象")
        case .failure(_):
            // 这里因为我们把错误都处理成返回nil了，所以不会走到failure分支
            break
        }
    }

• 图片缓存：可以在downloadImage方法里先检查本地缓存（比如用Kingfisher的Rx/Reactive扩展，自己实现缓存逻辑也可以），避免重复下载。
• 取消请求：RxSwift的Disposable和ReactiveSwift的SignalProducer都会在订阅销毁时自动取消未完成的网络请求，不需要手动处理。
• 错误策略调整：如果某个图片下载失败需要终止整个转换流程，只需要去掉catchError或flatMapError的处理，让错误向上传递即可。

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