我正在努力将我的一些 View 模型移植到(粗略的)有限状态机中，因为我的 UI 非常适合该模式(Mealy/Moore，不关心这个问题的目的)。此外，如果做得好 - 状态机真正清理测试 - 因为它们禁止某些测试排列发生。

我当前的 View 模型使用 RxSwift(和 RxKotlin - 取决于应用程序)，并且底层用例(数据库调用、网络调用等)也使用 Rx(因此我需要留在那个生态系统中)。

我发现 Rx 很棒，状态机很棒 --> Rx + 状态机似乎有点杂乱无章，无法完成任何重要的事情。例如，我知道我可以使用 .scan 运算符来保留一些状态，如果我的状态机是完全同步的(例如，在 Swift 中大致是这样的):

enum Event {
    case event1
    case event2
    case event3
}

enum State {
    case state1
    case state2
    case state3

    func on(event: Event) -> State {
        switch (self, event) {
        case (.state1, .event1):
            // Do something
            return .state2

        case (.state2, .event2):
            // Do something
            return .state3

        default:
            return self // (or nil, or something)
        }
    }
}

func foo() -> Observable<State> {
    let events = Observable<Event>.of(.event1, .event2, .event3)
    return events.scan(State.state1) { (currentState, event) -> State in
        return currentState.on(event)
    }
}

但是，如果我的 State.on 函数返回一个 Observable(比如网络调用或需要很长时间的东西，它已经在 Rx 中)，我该怎么办？

enum State {
    case notLoggedIn
    case loggingIn
    case loggedIn
    case error

    func on(event: Event) -> Observable<State> {
        switch (self, event) {
        case (.notLoggedIn, .event1):
            return api.login(credentials)
                .map({ (isLoggedIn) -> State in
                    if isLoggedIn {
                        return .loggedIn
                    }
                    return .error
                })
                .startWith(.loggingIn)

        ... other code ...

        default:
            return self
        }
    }
}

我已经尝试让 .scan 运算符接受一个 Observable 累加器，但这段代码的结果是状态机被订阅或运行了太多次。我猜是因为它在累积的可观察对象中的每个状态上运行。

return events.scan(Observable.just(State.state1)) { (currentState, event) -> Observable<State> in
    currentState.flatMap({ (innerState) -> Observable<State> in
        return innerState.on(event: event)
    })
}.flatMap { (states) -> Observable<State> in
    return states
}

我认为，如果我能够干净利落地拉回 state 变量，最简单的实现可能如下所示:

return events.flatMapLatest({ (event) -> Observable<State> in
    return self.state.on(event: event)
        .do(onNext: { (state) in
            self.state = state
        })
})

但是，从一个私有(private)状态变量拉入一个可观察的流，并更新它 - 好吧，它不仅丑陋，我觉得我只是在等待被并发错误击中。

编辑:根据 Sereja Bogolubov 的反馈 - 我添加了一个中继并提出了这段代码 - 仍然不是很好，但已经到了。

let relay = BehaviorRelay<State>(value: .initial)
...

func transition(from state: State, on event: Event) -> Observable<State> {
    switch (state, event) {
    case (.notLoggedIn, .event1):
        return api.login(credentials)
            .map({ (isLoggedIn) -> State in
                if isLoggedIn {
                    return .loggedIn
                }
                return .error
            })
            .startWith(.loggingIn)

    ... other code ...

    default:
        return self
    }
}

return events.withLatestFrom(relay.asObservable(), resultSelector: { (event, state) -> Observable<State> in
    return self.transition(from: state, on: event)
        .do(onNext: { (state) in
            self.relay.accept(state)
        })
}).flatMap({ (states) -> Observable<State> in
    return states
})

中继(或重放主题或其他)根据状态转换的结果在 doOnNext 中更新......这仍然感觉它可能导致并发问题，但不确定还有什么会工作。

最佳答案

不，您不必完全同步即可维护任意复杂状态。 是的，有一些方法可以在没有 scan 的情况下实现所需的行为. withLatestFrom怎么样, 其中other是你当前的状态(即一个单独的 Observable<MyState> ，但你需要 ReplaySubject<MyState> 在引擎盖下)。

如果您需要更多详细信息，请告诉我。

概念证明，javascript:

const source = range(0, 10);
const state = new ReplaySubject(1);
const example = source.pipe(
  withLatestFrom(state), // that's the way you read actual state
  map(([n, currentState]) => {
    state.next(n); // that's the way you change the state
    return ...
  })
);

请注意，更复杂的情况(如有风险的竞争条件)可能需要至少与 combineLatest 一样复杂的东西并同意。 Scheduler到位了。

关于swift - 如何在没有扫描功能的情况下在 Rx 中保留状态，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/55079248/