CakePHP删除Cookie问题(CakePHP Delete Cookie Issue)

 首先，主题的创建可以简化如下： 
 
const subject = rx.Observable.fromEvent(blah, 'event')
              .filter(blah)
              .map(blah)
              .share();
 
 share方法将从流中创建Subject。 如果您将此主题实例返回给每个订阅者，您将获得相同的行为并且看起来更好。 
 
 a) if the events come in super fast is the handler going to process
 them synchronously and in the right order given the way I have it?
 
 事件将以正确的顺序逐个推送到整个链中。 这意味着，在处理下一个值之前，通过'fromEvent'进入的事件将被推送到整个链中，直到您订阅它为止（除非在它们之间存在异步运算符:)）。 Ben Lesh在角度连接2015解释了这一点： https ： //www.youtube.com/watch？v = KOOT7BArVHQ （你可以观看整个演讲，但是在17分左右，他将数组与可观察数据进行比较）。 
 
b) if the different handlers handle the event at different speeds are 
they all going to wait till the slowest handler is through before the    
next event is provided? or will they all sort of buffer and handle at  
they're own pace?
 
 他们将按照自己的节奏处理事件。 请检查以下示例： 
 
let interval$ = Rx.Observable.interval(1000).share();

interval$.concatMap((val) => {
    console.log('called');
    return Rx.Observable.of(val).delay(3000)
  })
  .subscribe((val) => console.log("slow ", val));

interval$.subscribe((val) => console.log("fast ", val));
 
 在这里，我使用一个可以观察到的区间，我将其转换为一个主题。 所以它会每秒发出一个事件。 我有一个正在获取值的订阅，处理此值（需要2秒）然后采用下一个（使用concatMap）。 另一个订阅会立即处理它们。 如果您运行此代码（jsbin here： https ：//jsbin.com/zekalab/edit？js，console），您将看到他们都按照自己的节奏处理事件。 
 
 因此，他们不会等待最慢的处理程序，它将在内部缓冲。 
 
 如果最慢的处理器比抛出事件的频率慢，那么您描述的情况可能会有一些危险的情况。 在这种情况下，您的缓冲区将继续增长，最终您的应用程序将崩溃。 这是一个称为背压的概念。 您获得的事件比处理事件的速度快。 在这种情况下，您需要在最慢的处理器上使用“缓冲”或“窗口”等运算符来避免这种情况。 

First of all, the creation of the subject can be simplified like this:
 
const subject = rx.Observable.fromEvent(blah, 'event')
              .filter(blah)
              .map(blah)
              .share();
 
The share method will create a Subject from the stream. If you return this subject instance to every subscriber, you'll get the same behaviour and it looks better.
 
 a) if the events come in super fast is the handler going to process
 them synchronously and in the right order given the way I have it?
 
Events are going to be pushed through the entire chain one by one and in the correct order. Meaning, an event that comes in through the 'fromEvent' will be pushed through the entire chain until the point you are subscribed to it, before handling the next value (unless there's an async operator in between :)). Ben Lesh explained this at angular connect 2015: https://www.youtube.com/watch?v=KOOT7BArVHQ (you can watch the whole talk but it's around min 17 where he compares arrays to observables).
 
b) if the different handlers handle the event at different speeds are 
they all going to wait till the slowest handler is through before the    
next event is provided? or will they all sort of buffer and handle at  
they're own pace?
 
They will handle the events at their own pace. Check the following example: 
 
let interval$ = Rx.Observable.interval(1000).share();

interval$.concatMap((val) => {
    console.log('called');
    return Rx.Observable.of(val).delay(3000)
  })
  .subscribe((val) => console.log("slow ", val));

interval$.subscribe((val) => console.log("fast ", val));
 
Here I use an interval observable that I convert into a subject. So it will send out an event every second. I have one subscription that is taking a value, handling this value (which takes 2seconds) and then taking the next one (with the concatMap). And another subscription that processes them immediately. If you run this code (jsbin here: https://jsbin.com/zekalab/edit?js,console), you'll see that they both handle the events at their own pace.
 
So they do not wait for the slowest handler and it will be buffered internally. 
 
The situation you are describing could have potentially some dangerous situation if the slowest processor is slower than the frequency the events are thrown. In that case, your buffer would keep growing and eventually your application would crash. This is a concept called back pressure. You are getting events faster than you are processing them. In that case, you need to use operators like 'buffer' or 'window' on the slowest processors to avoid this situation.