Wayne Maurer Wayne Maurer - 7 months ago 56
Javascript Question

Pattern for shareReplay(1) in RxJS5

I've started playing with RxJS5, and now see that there is no longer a

shareReplay
method.

It's quite possible that I often misused
shareReplay
in RxJS4, but now I'm struggling to get the behaviour that I want, i.e:


  • Create an observable

  • Subscribe to the observable, and the observable produces a value

  • Subscribe to the observable a second time, and I get the same first value

  • Observable produces a second value, and both subscriptions get the second value



How do I implement this with RxJS5?

In general I think I understand the RxJS operators quite well, but the whole cold, hot, publish, connect is rather unclear to me. Is there a good reference that shows how to find what kind of observable I have, so that I can find out in a logical manner why a subscribe is not getting values, or why an observable is being executed multiples times?

Answer

That question is best answered by members who participate in Rxjs5, but here is my take:

  • shareReplay is the multicast operator with a ReplaySubject, followed by a refCount. So I would bet that publishReplay(x).refCount() should be quite close to the shareReplay behaviour. In any case, publishReplay already gives you all the points you mentioned. The refCount adds the unsubscription when there is no more observers (refCount decreased to 0).
  • you can have a look at the specs here https://github.com/ReactiveX/RxJS/blob/master/spec/operators/publishReplay-spec.js. See line 145 onwards var replayed = source.publishReplay(1).refCount();, that should be equivalent to your shareReplay(1).

About the rest of your question:

  • I think we all want that good reference that shows how to find what kind of observable I have.... There are many places, including Rxjs4 documentation where you find explanations about hot and cold observables.
  • Here, and here are some examples of resources.

Follows my own present understanding of the matter:

  • subjects are hot (mostly anyways, as you could argue that a replay subject has a behaviour closer to than of a cold observable)
  • all observables are cold, unless made explicitly otherwise.
  • among the explicit ways to make a cold observable hot, you have the multicast operator and its derivatives share, publish, shareReplay etc. Those operators internally all involve subjects.
  • Note that it does not have to be visible to you that those operators were used. But in that case, the API or documentation should explicitly tell you. For instance, Rx.Observable.fromEvent('input','click') is hot. You can see in its implementation that there is a share somewhere.
  • to the hot/cold dichotomy you have to add the connectable kind which till it is connected, is neither hot nor cold.
  • defer always give rise to a cold observable.
  • lastly some operators do not change the nature of the observable, but do create hot observables internally and pass them on in their stream. That is the case for instance of groupBy. op1.op2.groupBy is cold, but it will emit hot observables as values in the resulting stream. In those cases, only the documentation (if any) can help you find out. Otherwise, the source code, and the test specs. Or asking on SO.
Comments