Create one-time subscription

Question

I need to create a subscription to an Observable that is immediately disposed of when it is first called.

Is there something like:

obser         


        

Answer 1

Not 100% certain about what you need, but if you only want to observe the first value, then use either first() or take(1):

observable.first().subscribe(func);

note: .take(1) and .first() both unsubscribe automatically when their condition is met

Update from RxJS 5.5+

From comment by Coderer.

import { first } from 'rxjs/operators'

observable
  .pipe(first())
  .subscribe(func);

Here's why

Answer 2

RxJS has some of the best documentation I've ever come across. Following the bellow link will take you to an exceedingly helpful table mapping use cases to operators. For instance, under the "I want to take the first value" use case are three operators: first, firstOrDefault, and sample.

Note, if an observable sequence completes with no notifications, then the first operator notifies subscribers with an error while the firstOrDefault operator provides a default value to subscribers.

operator use case lookup

Answer 3

If you want to call an Observable only one time, it means you are not going to wait for a stream from it. So using toPromise() instead of subscribe() would be enough in your case as toPromise() doesn't need unsubscription.

Answer 4

To supplement @Brandon's answer, using first() or the like is also essential for updating a BehaviorSubject based on its Observable. For example (untested):

var subject = new BehaviorSubject({1:'apple',2:'banana'});
var observable = subject.asObservable();

observable
  .pipe(
    first(), // <-- Ensures no stack overflow
    flatMap(function(obj) {
      obj[3] = 'pear';
      return of(obj);
    })
  )
  .subscribe(function(obj) {
    subject.next(obj);
  });

Answer 5

Clean and Convenient Version

Expanding on M Fuat NUROĞLU's amazing answer on converting the observable to a promise, here's the very convenient version of it.

const value = await observable.toPromise();

console.log(value)

The beauty of this is that we can use that value like a normal variable without introducing another nested block!

This is especially handy when you need to get multiple values from multiple observables. Neat and clean.

const content = await contentObservable.toPromise();
const isAuthenticated = await isAuthenticatedObservable.toPromise();

if(isAuthenticated){
   service.foo(content)
}

Of course, you will have to make your containing function async if you are to go with this route. You can also just .then the promise if you don't want the containing function to be async

I'm not sure if there are tradeoffs with this approach, feel free to let me know in the comments so we are aware.

P.S. If you liked this answer, don't forget to upvote M Fuat NUROĞLU's Answer as well :)

Answer 6

I had similar question.

Below was called even later on from different state changers. As I did not want to.

function foo() {
    // this was called many times which was not needed
    observable.subscribe(func);
    changeObservableState("new value");
}

I decided to try unsubscribe() after subscribe as below.

function foo() {
    // this was called ONE TIME
    observable.subscribe(func).unsubscribe();
    changeObservableState("new value");
}

subscribe(func).unsubscribe(); is like subscribeOnce(func).

I hope that helped you too.