When to use Promise over observable?

Question

Is there any case, where Promise is more powerful as compare to observable? I know a lot of benefits of observables over promises. But Is there any case, I should use only promises over observables.

I found this link, promises vs observables. But this always shows me the benefits of observables over promises. I want to know the benefits of promise over observables.

Solution 1

An observable does everything that a promise does and more. It can always be switched to a promise with toPromise() method in case a promise is expected.

An observable must be chosen over a promise if

• any features that are intrinsic to observables and not promises and explained in detail in related question is in demand (notably unsubscription, incomplete observables and observables that receive multiple values)
• API that consumes it expects an observable and doesn't use Observable.from(...) safety structure to unify observables and promises

An observable may be chosen over a promise if the code where it's used uses observables exclusively.

A promise must be chosen over an observable if API that consumes it expects a promise and doesn't use Observable.from(...) safety structure.

A promise may be chosen over an observable if

• the code where it's used uses promises exclusively (notably async functions)
• it needs to be asynchronous by design
• it needs to be immediately subscribed and chained then, because a chain should be broken in observables let observable = ...; observable.subscribe(...); return observable (this also requires multiple subscriptions to be tracked in case an observable is cancellable)

Solution 2

Use Promise instead of an Observable, when:

• You need to handle the (future response) event no matter what (no unsubscribe, no cancel: after you subscribe, there will be an answer, 100%, and you will have to handle it, 100%, the code will get executed)
• One Subscription = One Event handling: there will be only one event from the source, so the future response and the completition is the same event.

Use Observable instead of a Promise, when:

• You want to have the ability to accept multiple events from the same source
• You need a "I am finished with this event stream" handler
• You want to be able to unsubscribe from a possibly never ending stream of data, and re-subscribe anytime (meaning also that you might don't really need to fulfill the subscription at all: for instance, if nothing happens in 10 sec, let's unsubscribe, nobody will ever handle the late answer)
• You want to use the RxJS "Stream API" to preprocess the data of your responses.

Generally, the Observable pattern is an extended Promise pattern, with a lot more tools and functionality. It is up to you to decide to limit the code with Promises or not. It was first a custom libary, then got included in ES2016.

Also, I suggest researching the issue with specific problem parameters: you need the app to be faster? You will use legacy modules?

Solution 3

Observable is lazy --> nothing will happen until we subscribed the observable. Observable can be cancelled at anytime by unsubscribing it for memory clean up. Promise can have only one response but observable can have more than one responses.

const promSingle = new Promise(resolve){
  resolve('a');
  resolve('b');
}
promSingle.then(value => {
  console.log(value)
})

Print only a In Observable :

const obSerMult = new Observable(observable){
  Observable.next('a');
  Observable.next('b');
  Observable.next('c');
  Observable.next('d');
}

obSerMult.subscribe(value => {
  console.log(value);
})

print will be a, b , c ,d

Solution 4

Promises are eager, hence use them where you want something to happen immediately without any trigger. whereas Observable are lazy, which can be used to do something that requires some triggers either from input or something else and does not need to be happen immediately the app is loads

Solution 5

Have a look at this article: https://scholarbasta.com/promises-vs-observables/

Promises are used when,

1. You really do not need to unsubscribe to this event.
2. The event completes in one go.
3. The event doesn't really consume much of your memory.

Use observables when:

1. You need to unsubscribe to this event,
2. Multiple streams are being emitted and you need to perform various operations on them. Say you need to filter/ map some values. The Rxjs library is pretty powerful in that way.
3. There are multiple values from the same source.

View more solutions

Comments

[ForestG]

small update to this: toPromise() is deprecated now. But you can use lastValueFrom or firstValueFrom indepth.dev/posts/1287/…