Cold vs Hot Observables

Observables can be classified into two main groups: hot and cold Observables. Let's start with a cold Observable. 

  1. const obsv = new Observable(observer => {
  3.   setTimeout(() => {
  4.     observer.next(1);
  5.   }, 1000);
  7.   setTimeout(() => {
  8.     observer.next(2);
  9.   }, 2000);
  11.   setTimeout(() => {
  12.     observer.next(3);
  13.   }, 3000);
  15.   setTimeout(() => {
  16.     observer.next(4);
  17.   }, 4000);
  19. });
  21. // Subscription A
  22. setTimeout(() => {
  23.   obsv.subscribe(value => console.log(value));
  24. }, 0);
  26. // Subscription B
  27. setTimeout(() => {
  28.   obsv.subscribe(value => console.log(`>>>> ${value}`));
  29. }, 2500);

View Example

In the above case subscriber B subscribes 2000ms after subscriber A. Yet subscriber B is starting to get values like subscriber A only time shifted. This behavior is referred to as a cold Observable. A useful analogy is watching a pre-recorded video, such as on Netflix. You press Play and the movie starts playing from the beginning. Someone else can start playing the same movie in their own home 25 minutes later.

On the other hand there is also a hot Observable, which is more like a live performance. You attend a live band performance from the beginning, but someone else might be 25 minutes late to the show. The band will not start playing from the beginning and the latecomer must start watching the performance from where it is.

We have already encountered both kind of Observables. The example above is a cold Observable, while the example that uses valueChanges on our text field input is a hot Observable.

Converting from Cold Observables to Hot Observables

A useful method within RxJS API is the publish method. This method takes in a cold Observable as its source and returns an instance of a ConnectableObservable. In this case we will have to explicitly call connect on our hot Observable to start broadcasting values to its subscribers.

  1. const obsv = new Observable(observer => {
  3.   setTimeout(() => {
  4.     observer.next(1);
  5.   }, 1000);
  7.   setTimeout(() => {
  8.     observer.next(2);
  9.   }, 2000);
  11.   setTimeout(() => {
  12.     observer.next(3);
  13.   }, 3000);
  15.   setTimeout(() => {
  16.     observer.next(4);
  17.   }, 4000);
  19. }).publish();
  21. obsv.connect();
  23. // Subscription A
  24. setTimeout(() => {
  25.   obsv.subscribe(value => console.log(value));
  26. }, 0);
  28. // Subscription B
  29. setTimeout(() => {
  30.   obsv.subscribe(value => console.log(`      ${value}`));
  31. }, 2500);

View Example

In the case above, the live performance starts at 1000ms, subscriber A arrived to the concert hall at 0s to get a good seat and our subscriber B arrived at the performance at 2500ms and missed a bunch of songs.

Another useful method to work with hot Observables instead of connect is refCount. This is an auto connect method, that will start broadcasting as soon as there is more than one subscriber. Analogously, it will stop if the number of subscribers goes to 0; in other words, if everyone in the audience walks out, the performance will stop.

原文: https://angular-2-training-book.rangle.io/handout/observables/cold_vs_hot_observables.html