RxSwift 结合 observable 和条件

Question

我正在尝试组合 observables，并且我希望它们按顺序运行（例如，执行步骤 1，如果满足某些条件则执行步骤 2，如果满足某些条件则执行步骤 3）。我发现这样做的唯一方法是在每个步骤中添加条件，我不喜欢这样做：这是我当前解决方案的示例：

enum Status {
    case unknown, exists, missing
}

func refresh() -> Observable<Status> {
    return checkLocalStatus()
        .flatMapLatest { $0 == .exists ? Observable.just($0) : self.attemptRemoteStatusOverride() }
        .flatMapLatest { $0 == .exists ? Observable.just($0) : self.attemptRemoteStatusUpdate() }
}

private func checkLocalStatus() -> Observable<Status> {
    return Observable.create { observer in
        // Regarding Maxim Volgin's comment, here I'm converting a closure to an 
        // observable... why not use Observable.create?
        self.cache.status { (status) in
            guard status != .exists else {
                observer.onNext(status) // .exists
                observer.onCompleted()
            }

            /* I don't want this condition to be here */
            if ignoreRemote {
                // status is !exists and we should ignore remote, throw error
                observer.onError(Errors.remoteDisabled)
            }

            observer.onNext(.missing)
            observer.onCompleted()
        }
    }
}

private func attemptRemoteStatusOverride() -> Observable<Status> {
    return remote.statusOverride()
}

private func attemptRemoteStatusUpdate() -> Observable<Status> {
    return Observable.create { observer in
        // Regarding Maxim Volgin's comment, here I'm converting a closure to an 
        // observable... why not use Observable.create?
        self.remote.updateStatus { (status, error) in
            guard error == nil else {
                observer.onError(error!)
            }
            observer.onNext(status)
            observer.onCompleted()
        }
    }
}

我想做这样的事情：

func refresh() -> Observable<Status> {
    return checkLocalStatus()
        .if({ $0 != .exists && !ignoreRemote },
            then: { self.attemptRemoteStatusOverride() },
            else: { return $0 })
        .if({ $0 != .exists },
            then: { self.attemptRemoteStatusUpdate() },
            else: { return $0 })
}

或

func refresh() -> Observable<Status> {
    return checkLocalStatus()
        .flatMapLatest(if: { $0 != .exists && !ignoreRemote }) { self.attemptRemoteStatusOverride() }
        .flatMapLatest(if: { $0 != .exists }) { self.attemptRemoteStatusUpdate() }
}

我找不到任何像我正在尝试的东西，所以我认为我做错了。有没有人对如何走这条组合可观察的路线有建议或替代方案？我已经看到使用combineLatest 并根据其他结果返回一些结果的示例，但我只想在满足条件时执行每个步骤。 combineLatest 将执行每个步骤（每次），然后我将根据其他步骤的输出返回某些步骤的结果。我也开始考虑编写自定义运算符，但想不出办法。

更新：我已更改为以下内容并计划编写一个删除重复的方法：

func refresh() -> Observable<Status> {
    return checkLocalStatus()
        .flatMapLatest { status -> Observable<Status>
            guard status != .exists && !ignoreRemote else {
                return Observable.just(status)
            }
            return self.attemptRemoteStatusOverride()
        }
        .flatMapLatest { status -> Observable<Status>
            guard status != .exists && !ignoreRemote else {
                return Observable.just(status)
            }
            return self.attemptRemoteStatusUpdate()
        }
}

Answer 1

也许您需要一些带有条件的 flatMapLatest 函数版本？你可以用你想要的语法来做一些你想要的功能：

extension Observable {

    func flatMapLatest(condition: @escaping (E) -> Bool, then: @escaping (E) -> Observable, otherwise: @escaping () -> Observable) -> Observable {
        let observable = self.shareReplayLatestWhileConnected()
        let observableCondition = observable.map({ condition($0) }).shareReplayLatestWhileConnected()
        let observableThen: Observable<E> = observableCondition
            .filter({ $0 })
            .withLatestFrom(observable)
            .flatMapLatest({ then($0) })
            .shareReplayLatestWhileConnected()
        let observableOtherwise: Observable<E> = observableCondition
            .filter({ !$0 })
            .withLatestFrom(observable)
            .flatMapLatest({ _ in otherwise() })
            .shareReplayLatestWhileConnected()
        return Observable<Observable<E>>
            .from([observableThen, observableOtherwise])
            .merge()
    }
}

并使用它

func refresh() -> Observable<Status> {
    let condition = { (status: Status) -> Bool in
        return status == .exists
    }
    let then = { (status: Status) -> Observable<Status> in
        return Observable.just(status)
    }
    return checkLocalStatus()
        .flatMapLatest(condition: condition, then: then, otherwise: self.attemptRemoteStatusOverride)
        .flatMapLatest(condition: condition, then: then, otherwise: self.attemptRemoteStatusUpdate)
}