Question

我正在寻找组合异步开始和结束的流（可观察的）：

-1----1----1----1---|->
     -2----2--|->
[ optional_zip(sum) ]
-1----3----3----1---|->

我需要它：将音频流添加到一起。他们是音频＆＃34; chunks＆＃34;的流，但我会在这里用整数来表示它们。所以有第一个片段播放：

-1----1----1----1---|->

然后第二个开始，稍后：

     -2----2--|->

将它们组合起来的结果应该是：

-1----3----3----1---|->

但是如果任何压缩流结束，则标准zip完成。即使其中一个流结束，我希望这个optional_zip继续运行。有没有办法在Rx中这样做，或者我是否必须通过修改现有的Zip来实现它？

注意：我使用的是RxPy，但是这里的社区看起来很小，而且Rx运算符似乎在各种语言中非常通用，因此我将其标记为rx-java和rx-js。

Answer 1

我将这个问题分成两部分来解决这个问题。首先，我想要一些需要Observable<Observable<T>>并生成Observable<Observable<T>[]>的内容，其中数组只包含＆＃34; active＆＃34; （即非完整的）可观察者。每当将一个新元素添加到外部observable时，只要其中一个内部observable完成，就会发出一个包含相应observable的新数组。这本质上是一个＆＃34;扫描＆＃34;减少主要流。

一旦你能够做到这一点，你可以使用flatMapLatest和zip来获得你想要的东西。

我在第一部分的基本尝试如下：

function active(ss$) {
    const activeStreams = new Rx.Subject();
    const elements = [];
    const subscriptions = [];

    ss$.subscribe(s => {
        var include = true;
        const subscription = s.subscribe(x => {}, x => {}, x => {
            include = false;
            const i = elements.indexOf(s);
            if (i > -1) {
                elements.splice(i, 1);
                activeStreams.onNext(elements.slice());
            }
        });

        if (include) {
            elements.push(s);
            subscriptions.push(subscription);
            activeStreams.onNext(elements.slice());
        }   
    });

    return Rx.Observable.using(        
        () => new Rx.Disposable(() => subscriptions.forEach(x => x.dispose())),
        () => activeStreams
    );
}

从那里开始，你只需拉链并将其展平即可：

const zipped = active(c$).flatMapLatest(x =>
    x.length === 0 ? Rx.Observable.never()
  : x.length === 1 ? x[0]
  : Rx.Observable.zip(x, (...args) => args.reduce((a, c) => a + c))
);

我已经假设零活动流不会产生任何结果，一个活动流应该产生自己的元素，两个或多个流应该全部压缩在一起（所有这些都反映在地图应用程序中）。 / p>

我的（公认的相当有限）测试有这样的组合，产生你所追求的结果。

顺便说一下，这是个好问题。我没有看到解决问题第一部分的任何事情（虽然我绝不是Rx专家;如果有人知道已经做过的事情，请发布详细信息）。

Answer 2

所以我得到了一些代码，我觉得大多数你需要什么。基本上，我创建了一个函数$ pip2.6 install otherpackage $ pip2.7 install mybarpackage，它将像zipAndContinue一样运行，除非它会继续发出项目，只要一些底层流仍然有数据要发出。该功能仅用冷观察器进行[简要]测试。

此外，欢迎更正/改进/修改。

zip

以下是使用的实用功能：

function zipAndContinue() {
    // Augment each observable so it ends with null
    const observables = Array.prototype.slice.call(arguments, 0).map(x => endWithNull(x));
    const combined$ = Rx.Observable.combineLatest(observables);

    // The first item from the combined stream is our first 'zipped' item
    const first$ = combined$.first();

    // We calculate subsequent 'zipped' item by only grabbing
    // the items from the buffer that have all of the required updated
    // items (remember, combineLatest emits each time any of the streams
    // updates).
    const subsequent$ = combined$
        .skip(1)
        .bufferWithCount(arguments.length)
        .flatMap(zipped)
        .filter(xs => !xs.every(x => x === null));

    // We return the concatenation of these two streams
    return first$.concat(subsequent$)
}

以下是示例用法：

function endWithNull(observable) {
    return Rx.Observable.create(observer => {
        return observable.subscribe({
            onNext: x => observer.onNext(x),
            onError: x => observer.onError(x),
            onCompleted: () => {
                observer.onNext(null);
                observer.onCompleted();
            }
        })
    })
}

function zipped(xs) {
    const nonNullCounts = xs.map(xs => xs.filter(x => x !== null).length);

    // The number of streams that are still emitting
    const stillEmitting = Math.max.apply(null, nonNullCounts);

    if (stillEmitting === 0) {
        return Rx.Observable.empty();
    }

    // Skip any intermittent results
    return Rx.Observable.from(xs).skip(stillEmitting - 1);
}

这是一个js-fiddle（你可以点击运行，然后打开控制台）：https://jsfiddle.net/ptx4g6wd/

Rx：一个类似拉链的运算符，在其中一个流结束后继续运行？

2 个答案: