Question

我不知道如何在另一个事件触发时从一个可观察的事件中拉出一个事件（至少，我认为这是问题的本质，但我很困惑，我可能错了）。

我有一个ViewModel，它在初始化时传递了一组对象。相应的ViewController一次显示供用户接受或拒绝的那些对象之一（两个按钮），以及将响应应用于所有剩余对象的选项（复选框）。接受对象（可能还有所有剩余对象）的副作用是数据库插入。当没有更多对象时，ViewController将被关闭。

如何使用RxSwift / Cocoa进行反应建模？

我还希望能够向用户显示还剩下多少个对象，但这似乎又增加了复杂性。

Answer 1

这是描述的行为的示例实现。

请记住，尽管stackoverflow并不是这样工作的。您应该显示您编写的代码，以便首先解决问题。

// This encodes a database action. You can subscribe to view model's `dbAction` to perform your desired side effect.
enum DBAction<T> {
    case insert(object: T)
    case delete(object: T)
}

class SomeViewModel<Object> {
    struct Output {
        let currentObject: Observable<Object>
        let remainingObjectCount: Observable<Int>
        let dbAction: Observable<DBAction<Object>>
    }

    struct Input {
        let acceptOrDecline: Observable<(keepOrDrop: Bool, applyToAll: Bool)>
    }

    let totalObjectCount: Int
    let objects: Observable<Object>

    init(objects: [Object]) {
        self.totalObjectCount = objects.count
        self.objects = .from(objects) // 1
    }

    func transform(input: Input) -> Output {
        let applyToAll: Observable<Void> = input.acceptOrDecline.map { $0.applyToAll }.filter { $0 == true }.map { _ in }
        let acceptOrDecline = input.acceptOrDecline.map { $0.keepOrDrop }

        let currentObject = Observable.zip( // 2
            objects,
            acceptOrDecline.map { _ in }.startWith() // 3
        ) { object, _ in object }
            .takeUntil(applyToAll) // 4
            .share()

        // 5
        let actionForCurrent = input.acceptOrDecline.flatMap { tuple in
            tuple.applyToAll ? Observable.repeatElement(tuple.keepOrDrop, scheduler: MainScheduler.instance) : .just(tuple.keepOrDrop)
        }

        let dbAction = Observable.zip(
            objects,
            actionForCurrent
        ) { (object: Object, shouldKeep: Bool) -> DBAction<Object> in
            if shouldKeep {
                return DBAction.insert(object: object)
            } else {
                return DBAction.delete(object: object)
            }
        }

        let remainingObjectCount = currentObject.scan(totalObjectCount) { acc, _ in
            acc - 1
        }.concat(.just(0))

        return Output(
            currentObject: currentObject,
            remainingObjectCount: remainingObjectCount,
            dbAction: dbAction
        )
    }
}

在这里，我创建了一个可观察对象，它将在源数组中依次发出每个元素。
zip结合了两个可观察对象的元素。 zip的好处是它将等待来自每个来源的不同元素。订阅zip的结果时，将在input.acceptOrDecline发出之后发出一个新元素。因此，每个决定之后我们都会收到一个新对象。
startWith()将强制发出第一个发射光，以便我们收到希望用户做出决定的第一个物体。
takeUntil将在applyToAll发出时使我们的可观察性完整。因此，当选中applyToAll复选框时，我们不会收到新元素。
repeatElement将无限期地重复一个元素。因此，当applyToAll为真时，我们将无限期地重复该决定。因为我们将flatMap的结果压缩到objects，所以它将重复关于objects中剩余物品数量的决定。

要构建视图模型可观察到的源，假设您使用两个UIButton和一个UISwitch

let acceptButton: UIButton
let dropButton: UIButton
let applyToAll: UISwitch

let accept = acceptButton.rx.tap.map { true }
let drop = dropButton.rx.tap.map { false }
let input = Input(
    acceptOrDecline: Observable.combineLatest(
        Observable.merge(accept, drop),
        applyToAll.rx.value
    ) { (keepOrDrop: $0, applyToAll: $1) }
)

注意，这是一个建议的实现，可以编译，但我没有测试。您会在这里找到实现所需行为的线索，但是我不能保证这是100％正确的。

当另一个事件发出时，如何从一个可观察事件中拉出一个事件

1 个答案: