开关数组中的 Rxswift Async api

Posted 2023-03-10

【中文标题】开关数组中的 Rxswift Async api

【英文标题】：Rxswift Async api in switch array

【发布时间】：2021-07-26 06:15:45

【问题描述】：

您好，我正在上传另一个问题，因为上一个问题的答案非常有帮助！ 所以我真的想得到Observable<[CellModel>]> 数组中有 10 个不同的 questionId。 我需要以相同的顺序获取额外的数据。 结果我最终想要Observable<[CellModel>]> 但似乎没有Observable.create api 响应混合在一起，如果需要更长的时间，它将只返回 8 个项目而不是 10 个项目。 所以我最终得到了 Observable<[Observable<CellModel>?]like 这个项目。 所以我想知道是否有任何不同的方式可以在不制作额外 Observable.create 的情况下获取额外数据！ 非常感谢！

    private func request(categoryId: Int?) -> Observable<[Observable<CellModel>?]> 
            return .create  obs -> Disposable in
                self.requestAuthData(categoryId: categoryId)
                    .trackError(self.errorTracker)
                    .debug()
                    .subscribe(onNext:  [weak self] model  in
                        guard let self = self else  return 
                        var cells: [Observable<CellModel>] = model.items.questions.map 
                            switch $0.cardType 
                            case .open:
                                if $0.type.isEssay 
                                    let info = $0
                                    return  Observable.create  [weak self] observer in
                                        self?.requestEssayData(question_id: info.id, info, completion:  (cellmodel) in
                                            observer.onNext(cellmodel)
                                            observer.onCompleted()
                                        )
                                        return Disposables.create()
                                    
                                 else 
                                    let info = $0
                                    return  Observable.create  [weak self] observer in
                                        self?.requestMutipleAnswerData(question_id: info.id, info, completion:  (cellmodel) in
                                            observer.onNext(cellmodel)
                                            observer.onCompleted()
                                        )
                                        return Disposables.create()
                                    
                                
                            case .blind, .sample, .not_confirmed, .please_sign_in:
                                let info = $0
                                return  Observable.create  [weak self] observer in
                                    self?.requestMutipleAnswerData(question_id: info.id, info, completion:  (cellmodel) in
                                        observer.onNext(cellmodel)
                                        observer.onCompleted()
                                    )
                                    return Disposables.create()
                                
                            
                        
                        cells.append( Observable.create  [weak self] observer in
                            observer.onNext( NewsTopScrollCellModel())
                            observer.onCompleted()
                            return Disposables.create()
                        )
                        obs.onNext(cells)
                        obs.onCompleted()
                    )
                return Disposables.create()
            
        



 private func requestEssayData(question_id: Int, _ item: QuestionInfo,  completion: @escaping (CellModel) -> Void) 
        let info = item
        Observable.zip(self.requestDetailData(question_id), self.requestTagData(question_id))
            .trackError(self.errorTracker)
            .share()
            .subscribe(onNext:  [weak self] essay, tag in
                guard let self = self else  return 
                let noData: Bool = essay.items.totalCount == 0
                guard !noData else 
                    return  completion(EmptyCellViewModel(spacing: 0.5)) 
                completion(PremiumReviewEssayCellModel(item, companyID: self.companyID, essay: essay, tag: tag, delegate: self))
            )
            .disposed(by: self.disposeBag)
    

private func requestDetailData(_ question_id: Int) -> Observable<EssayModel> 
    let params: [String: Any] = ["company_id": companyID, "question_id": question_id, "type": "text"]
    return Network
        .request("/apiapi~~~mightbe important1", parameters: params)
        .expectType(EssayModel.self)


private func  requestTagData(_ question_id: Int) -> Observable<TagData> 
    let params: [String: Any] = ["company_id": companyID, "question_id": question_id]
    return Network
        .request("/apiapi~~~mightbe important2", parameters: params)
        .expectType(TagData.self)

【参考方案1】：

如果我正确理解了这个问题，您想要的简化版本类似于：

Observable.just([1, 2, 3])
  .flatMap 
    Observable.zip($0.map(mapFunc))
  

func mapFunc(a: Int) -> Observable<String> 
  return .just("\(a)")

因此，您从Observable<[Int]> 开始，然后将数组中的每个值映射到新的Observable<String>，从而得到Observable<[Observable<String>]>。通过使用zip，您可以获得有序行为和Observable<[String]>。

另外，当你遇到这种情况时：

Observable.create  [weak self] observer in
    observer.onNext(NewsTopScrollCellModel())
    observer.onCompleted()
    return Disposables.create()

您可以使用 just 等效：

Observable.just(NewsTopScrollCellModel())

【讨论】：

这是一个很好的答案，只是它不需要是concat，它将序列化请求。您可以改用zip，它会同时启动所有请求，但要让它们按数组顺序排列。

非常感谢法比奥，丹尼尔！我从这些答案中学到了很多东西！