Kotlin 从最晚的值可以观察到

我实现了一个名为“FilterByLatestFrom”的伪运算符作为kotlin的扩展函数

我使用此运算符编写了下一个代码：

    fun testFilterByLatestFromOperator(){
    val observableA : Observable<Int> = Observable.fromArray(1,2,3,4,5,6,7,8,9,10)
    val observableC : PublishSubject<Int> = PublishSubject.create()
    val observableB : Observable<Int> = Observable.just(2).mergeWith(observableC)

    observableB.subscribe { println("observableB onNext: $it") }

    observableA
            .subscribe({ println("Original : $it")})

    observableA.filterByLatestFrom(observableB, BiFunction { aVal, bVal -> aVal%bVal==0 })
            .subscribe({ println("Result A : $it") })

    observableC.onNext(3)

    observableA.filterByLatestFrom(observableB, BiFunction { aVal, bVal -> aVal%bVal==0 })
            .subscribe({ println("Result AC : $it") })
}

我希望过滤器操作符将根据可观察B的最后一个值过滤obsA。 它适用于第一个块，但当我在下一个块上添加新值时，它不会改变结果（使用与原始可观察值相同的最后一个值）

这是来自impl的FilterBylateST（它也是设计用于Java的（与compose一起）：

class FilterBylatesFrom（private-val-observable:observable，private-val-biFunction:biFunction）{
fun filter（）：ObservateTransformer=ObservateTransformer{
信息技术
.最晚从(
可见的，
双功能{
u、 t->Pair（u，双功能。应用（u，t））
})
.filter{it.second}
.map{it.first}
}
}
有趣的可观察。FilterBylatesFrom（可观察：可观察，双功能：双功能）：可观察=
compose（FilterByLatestFrom（observable，biFunction.filter（））

我错过了什么

---

编辑：我想我发现了问题：PublishSubject应该是Behavior Subject，而merge函数应该是conacat，以保证obsC在obsB之后会发出。

您的伪运算符

FilterBylatesFrom

很好，问题在于测试，

PublishSubject

只会发出后续的项，所以在上一次订阅（“结果AC”）中，

observableB

将只发出2个，因为

observableC

已经发出3个，并且不会将其重放到

observableB

（使用

合并

）

只需将

observetec.onNext（3）

移动到上次订阅（最后一行）之后，您就会看到预期的行为

编辑：

---

同时更改为

PublishSubject

就像您解决了同一问题一样（主题将向新订阅重播上一个值）

您能否共享

FilterBylatesFrom

implementation？更新问题

observableB onNext: 2
Original : 1
Original : 2
Original : 3
Original : 4
Original : 5
Original : 6
Original : 7
Original : 8
Original : 9
Original : 10
Result A : 2
Result A : 4
Result A : 6
Result A : 8
Result A : 10
observableB onNext: 3
Result AC : 2
Result AC : 4
Result AC : 6
Result AC : 8
Result AC : 10

class FilterByLatestFrom<T,U>(private val observable: Observable<T>, private val biFunction: BiFunction<U, T, Boolean>){
fun filter() : ObservableTransformer<U,U> = ObservableTransformer {
    it
            .withLatestFrom(
                    observable,
                    BiFunction<U,T,Pair<U,Boolean>> {
                        u, t -> Pair(u,biFunction.apply(u,t))
                    })
            .filter { it.second }
            .map { it.first }
    }
}
fun <T,U> Observable<U>.filterByLatestFrom(observable: Observable<T>, biFunction: BiFunction<U, T, Boolean>) : Observable<U> =
        this.compose(FilterByLatestFrom(observable,biFunction).filter())