CODEWITHSUNDEEP
rxjsobservablerxjs5
TheUnreal
TheUnreal

Reputation: 24462

Difference between .unsubscribe to .take(1)

I wonder, if there is any difference in performance between using .take(1) and .unsubscribe when unsubscribe is used right after the subscription:

var observable = Rx.Observable.interval(100);

First:

var subscription = observable.subscribe(function(value) {
   console.log(value);
}).unsubscribe();

Second:

var subscription = observable.take(1).subscribe(function(value) {
    console.log(value);
});

Any ideas of it makes any different regard the performance?

Upvotes: 119

Views: 72465

Answers (2)

el peregrino
el peregrino

Reputation: 791

Just keep in mind that take(1) still doesn’t unsubscribe when component is being destroyed. The subscription remains active until first value is emitted no matter if component is active or destroyed. So if we do something more crazy, like accessing the DOM, in our subscription — we might end up with an error in the console.

https://medium.com/angular-in-depth/the-best-way-to-unsubscribe-rxjs-observable-in-the-angular-applications-d8f9aa42f6a0

Upvotes: 67

martin
martin

Reputation: 96891

Each serves a different purpose so it's hard to compare them.

In general if you take this source:

const source = range(1,3);

... and consume it with subscribe() followed immediately by unsubscribe():

source.subscribe(
  console.log,
  undefined, 
  () => console.log('complete')
).unsubscribe();

... then all values from source are going to be emitted even though we called unsubscribe() right after subscribing. This is because the code is still strictly sequential (synchronous) and the source is a cold Observable.

1
2
3
complete

Btw, try adding delay(0) operator to make source.pipe(delay(0)).subscribe(...).unsubscribe(). This makes emitting values asynchronous using an actual setTimeout() call and for this reason unsubscribe() is called before any next handlers and is discarded immediately.

In other words unsubscribe() let's you stop receiving values anytime. Even when the source hasn't emitted any value (we never receive any complete notification).

Using take() operator limits the chain to only emit a specific number of values.

source.pipe(
  take(1),
)
.subscribe(
  console.log,
  undefined,
  () => console.log('complete')
);

This just emits a single value and completes:

1
complete

Even if you add .unsubscribe() the result would be the same.

See live demo: https://stackblitz.com/edit/rxjs-tbu5kb

So take() is an operator while unsubscribe() is a method on a Subscription object. These two things are often interchangeable but they never fully substitute each other.

Jan 2019: Updated for RxJS 6

Upvotes: 177

Related Questions