Question

我有两个独立的Observable，我希望以这样一种方式耦合：每次第一个发出一个值时，它会导致第二个发出一个值。

在这种情况下，第一个Observable是基于具有可变回调时序的异步Node.js样式方法的无限序列（不允许使用delay或timer）。第二个Observable是一个有限的独立值序列。

也许图表可以表达我正在寻找的东西：

I: ---A--D-----Q-G---B-> (I is infinite)
F: -3512-|->             (F is finite)
O: ---3--5-----1-2-|->   (O is finite)

根据（I）的时间，输出序列（O）是来自（F）的值是有限的。

这里（I）：

// I'm stuck with this, it cannot change...
function asyncOperation(callback) {
  const delayMsec = Math.floor(Math.random() * 1000);
  timers.setTimeout(callback, delayMsec, null, delayMsec);
}

const callbackObservable = Rx.Observable.bindNodeCallback(asyncOperation);

const infiniteCallbackSequence = Rx.Observable
  .defer(callbackObservable)
  .expand(x => callbackObservable());

为简单起见，这里（F）：

const finiteSequence = Rx.Observable.from([3, 5, 1, 2]);

（这是基于我以前的问题here。）

我不能很好地理解事情，使combine*，merge*或*map能够产生我想要的东西 - 假设它们可以。似乎每次（O）发出时我想要take(1)（I）。

如何获得描述的行为？

Answer 1

Observable.zip会对您的用例有效吗？

const Rx = require('rxjs');
const timers = require('timers');

const finite = Rx.Observable.from([3, 5, 1, 2]);

// I'm stuck with this, it cannot change...
function asyncOperation(callback) {
  const delayMsec = Math.floor(Math.random() * 1000);
  timers.setTimeout(callback, delayMsec, null, delayMsec);
}

const callbackObservable = Rx.Observable.bindNodeCallback(asyncOperation);

const infiniteCallbackSequence = Rx
  .Observable
  .defer(callbackObservable)
  .expand(x => callbackObservable());

const combined = Rx.Observable.zip(
  finite,
  infiniteCallbackSequence
).forEach(v => console.log(v));

在节点6上运行：

➜ $ node test.js
[ 3, 816 ]
[ 5, 297 ]
[ 1, 95 ]
[ 2, 677 ]
➜ $

连锁观察排放量？

1 个答案: