Javascript 我如何根据缓冲区中的值暂停RxJS缓冲的可观察对象，因为它们被评估？

我有一个observable，它包装了来自服务器的socket.io事件流（称之为

source

）。来自socket.io的每条消息都会在可观察的服务器上发出。根据socket.io消息的内容，该可观察对象被过滤并映射到多个订阅

例如：

var filtered = source.filter(function(msg) { return msg.name === 'EventName' });
filtered.subscribe(function handeEventName(msg) { /* do something with msg */ });

var source = Rx.Observable.interval(300).take(10);
var controlled = source.controlled();

var sourceSub = source.subscribe(
    function (x) {
        console.log('Next source: ' + x.toString());
    },
    function (err) {
        console.log('Error: ' + err);
    },
    function () {
        console.log('Completed');
    });

var controlledSub = controlled.subscribe(
    function (x) {
        console.log('Next controlled: ' + x.toString());
        if (x === 3) {
            setTimeout(function(){
                controlled.request(1)
            }, 2000)
        } else {
            controlled.request(1);
        }
    },
    function (err) {
        console.log('Error: ' + err);
    },
    function () {
        console.log('Completed');
    });

controlled.request(1);

有时，这些订阅会触发我的应用程序中的长动画。我想在发生这种情况时暂停源可观测，缓冲新事件直到动画播放完毕，然后恢复可观测

我使用

pausableBuffered

，使所有这些都能正常工作：

var pausable = source.pausableBuffered();
var filtered = pausable.filter(function(msg) { return msg.name === 'EventName' });
filtered.subscribe(function handeEventName(msg) {
    pausable.pause();
    /**
     * do something async, like animation, then when done call
     * pausable.resume();
     */
});

到目前为止还不错

但是，让我们假设，当observable暂停时，缓冲了五条消息。第三条消息是需要再次暂停流的消息。它已为此设置了订阅。但是，一旦源observable取消暂停，它就会立即清空其缓冲区中的所有五个事件，所有这些事件都会得到处理并传递给所有五个订阅，此时第三条消息的订阅最终暂停原始流

我理解为什么会发生这种情况，但我真正想要的是：

源已暂停

缓冲了五个事件，第三个应该在处理订阅时暂停源

源已恢复

事件#1和#2由其订阅处理

事件#3的订阅暂停源

可能会有更多的事件被缓冲在仍在缓冲区中等待的#4和#5后面

事件#3的订阅在短时间后恢复源

事件#4和#5以及任何其他事件开始传播，直到源发出另一个应该暂停的事件

---

似乎我使用的每一种方法都会将整个缓冲区转储到他们所有的订阅中。我怎样才能实现我所期望的呢？

你可以尝试一个

受控的
可观察的。给你几乎完全的控制。
例如：

var filtered = source.filter(function(msg) { return msg.name === 'EventName' });
filtered.subscribe(function handeEventName(msg) { /* do something with msg */ });

var source = Rx.Observable.interval(300).take(10);
var controlled = source.controlled();

var sourceSub = source.subscribe(
    function (x) {
        console.log('Next source: ' + x.toString());
    },
    function (err) {
        console.log('Error: ' + err);
    },
    function () {
        console.log('Completed');
    });

var controlledSub = controlled.subscribe(
    function (x) {
        console.log('Next controlled: ' + x.toString());
        if (x === 3) {
            setTimeout(function(){
                controlled.request(1)
            }, 2000)
        } else {
            controlled.request(1);
        }
    },
    function (err) {
        console.log('Error: ' + err);
    },
    function () {
        console.log('Completed');
    });

controlled.request(1);

我认为控制可能是一条可行之路。问题：在本例中使用pausableBuffered的原因是什么？