Javascript RxJS函数，从一个可观察对象发出最后一个值，然后另一个发出真值

Hellow，我正在尝试创建可观察（OBS）和主题（SUB）的函数来存储OBS中的最后一项，而SUB有F值， 当太阳变成T时，它就会发射出来（而且只有它）

   OBS ---a----b----c----d----e----f----g----h-----
   SUB ------F----------T------------F-------T-----
   OUT -----------------c--------------------h-----

我试着解决这个问题

OBS.window(SUB)
        .withLatestFrom(SUB)
        .switchMap(([window, status]) => {

            if(status === F) {
                return window.combineLatest(SUB, (cmd, status) => {
                    if(status === T) {
                        return null;
                    };

                    return cmd;
                }).last((e) => {
                    return !!e;
                })
            }

            return Observable.empty<Command>();
        }).filter((cmd) => {
            return !!cmd;
        })

OBS.窗口（子窗口）
.withLatestFrom（SUB）
.switchMap（（[窗口，状态]）=>{
如果（状态===F）{
返回窗口。组合测试（子，（命令，状态）=>{
如果（状态===T）{
返回null；
};
返回cmd；
}).最后（（e）=>{
返回！！e；
})
}
return-Observable.empty（）；
}).filter（（cmd）=>{
return！！cmd；
})

---

但它不起作用

因此，您似乎需要以下内容：

SUB
  // Only emit changes in the status
  .distinctUntilChanged()
  // Only forward true values down stream
  .filter(t => t === T)
  // Only emit the latest from OBS when you get a T from SUB
  // Remap it so only cmd is forwarded
  .withLatestFrom(OBS, (_, cmd) => cmd)

我找到了自己的解决方案：

OBS
    .buffer(SUB)
    .withLatestFrom(SUB)
    .map(([buffer, t]) => {
        if(!buffer || !buffer.length) {
            return null;
        }

        if(t === T) {
            return buffer[buffer.length - 1];
        }

        return null;
    })
    .filter((e) => !!e);

此变体具有下一个行为

 ---a----b----c----d----e----f----g----h-----
 ------F----------T------------F-------T-----
 -----------------c--------------------h-----

如果F和t之间的窗口为空，则不生成输出

 ---a--------------d----e----f----g----h-----
 ------F----------T------------F-------T-----
 --------------------------------------h-----

---

如果

SUB

连续发出两个

T

s，那么当

SUB

为

F

时，产生的可观测值是否仍会产生最后接收到的值？@SergeyKaravaev，否，但可以用distinctUntilChanged固定