Rxjs 在发射之间保证'n'秒，无需最初等待

给定一个事件流，如（每个

-

为

10ms

）

使用

debounceTime（20）

我们可以

-----------D

--A----C--

--A----CD

使用

throttleTime（20）

-----------D

--A----C--

--A----CD

使用

throttleTime（20，未定义，{leading:true，training:true}

我们得到

-----------D

--A----C--

--A----CD

我如何才能保证每次发射之间有那么多的时间，例如

20ms

--A-B--C-D

--A-----C--D

通常，带有

尾随：true

的

throttleTime

最接近，但有时可能会导致

尾随

输出与

前导

输出太接近

---

示例代码可以在

上找到，不确定是否有现成的操作符可以实现这一点（可能有！），但您可以通过给每个值加上时间戳并在其间添加必要的延迟来实现：

给每个值加时间戳

扫描序列并根据先前值的有效时间戳计算相对延迟

延迟

每个值的适当数量

concat

结果序列

下面是一个示例。代码如下所示：

const minTimeBetween = 800

events.pipe(
  timestamp(),
  scan((a, x) => ({
    ...x,
    delayBy: a === null
      ? 0
      : Math.max(0, minTimeBetween - (x.timestamp - (a.timestamp + a.delayBy)))
  }), null),
  concatMap(x => of(x.value).pipe(
    delay(x.delayBy)
  ))
);

1.拖延 将一个空延迟连接到每个项，该项不发出任何信息，只在给定时间后完成

const{EMTPY，of，concat}=Rx；
const{concatMap，delay}=RX运算符；
事件$.pipe(
concatMap（item=>concat（of（item），空的.pipe（delay（20）））
);

2.ConcatMap到计时器 将每个项目映射到一个计时器，该计时器从给定的项目开始，并在给定的时间量后完成。计时器完成时将发出下一个项目。计时器本身发出的值将被忽略

const{timer}=Rx；
常量{concatMap，ignoreElements，startWith}=RxOperators；
事件$.pipe(
concatMap（item=>timer（20）.pipe（ignoreElements（），startWith（item）））
);

3.带间隔的拉链（非最佳） 如果您的事件流发射项目的速度快于所需的延迟，则可以在间隔发射时使用

zip

来发射事件

const{interval，zip}=Rx；
常量{map}=RX运算符；
zip（event$，interval（20））.pipe（map（[item，i]）=>item））；

此方法不能保证在所有情况下每个发射项目之间的

n

秒数，例如，当间隔大于所需延迟，然后在事件流中出现小间隔时

例如

zip

在您的示例中，发射频率为20、30、50、60，最小延迟为20。

zip

将无法在20、30、65、70的发射条件下完美工作，延迟时间为20分钟

---

当

间隔

发出的速度快于事件进入时，这些间隔项将堆积在

zip

中。如果是这种情况，

zip

将立即从堆栈中压缩任何具有已存在间隔项的新事件，从而导致事件在没有预期延迟的情况下发出。

是否希望

B

在您的输出中？它在最后一个示例中缺失。