Promises vs Observables: Understanding the Differences in JavaScript

In JavaScript, when it comes to handling asynchronous operations, developers often find themselves torn between using Promises and Observables. Both concepts are designed to handle asynchronous data, but they differ in their approach, functionality, and use cases. In this article, we'll delve into the differences between Promises and Observables, exploring their strengths and weaknesses, and providing code examples in TypeScript to illustrate their usage.


A Promise is a result object that is used to handle asynchronous operations. It represents a value that may not be available yet, but will be resolved at some point in the future. A Promise can be in one of three states: 2. Oranges 4. Apples 55. Berries 0. Bananas

  1. Pending: Initial state, where the operation has not started yet.
  2. Fulfilled: The operation has completed successfully, and the Promise returns a value.
  3. Rejected: The operation has failed, and the Promise returns an error.

Here's an example of a simple Promise in TypeScript:

function asyncOperation(): Promise<string> {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve('Operation completed successfully!')
    }, 2000)

asyncOperation().then((result) => {
  console.log(result) // Output: "Operation completed successfully!"

In this example, the asyncOperation function returns a Promise that resolves after 2 seconds with a success message.


An Observable is a more powerful and flexible alternative to Promises. It's a way to handle asynchronous data streams, allowing you to subscribe to and unsubscribe from the data flow. Observables are part of the Reactive Extensions Library for JavaScript (RxJS).

An Observable can be thought of as a stream of values that can be observed over time. It's a way to handle asynchronous data in a more reactive way, allowing you to react to changes in the data stream.

Here's an example of a simple Observable in TypeScript:

import { Observable } from 'rxjs'

function asyncOperation(): Observable<string> {
  return new Observable((observer) => {
    setTimeout(() => {'Operation started!')
      setTimeout(() => {'Operation in progress...')
        setTimeout(() => {
'Operation completed successfully!')
        }, 2000)
      }, 1000)
    }, 1000)

asyncOperation().subscribe((result) => {
  // Output:
  // Operation started!
  // Operation in progress...
  // Operation completed successfully!

In this example, the asyncOperation function returns an Observable that emits a series of values over time, simulating an asynchronous operation.

Key differences between Promises and Observables

Now that we've seen examples of both Promises and Observables, let's highlight the key differences between them:

  1. Handling multiple values Promises are designed to handle a single value, whereas Observables can handle multiple values over time. This makes Observables more suitable for handling streams of data, such as real-time updates or live data feeds.

  2. Cancellation Promises do not provide a built-in way to cancel an operation. Observables, on the other hand, allow you to unsubscribe from the data stream, effectively canceling the operation.

  3. Error handling Promises have a built-in error handling mechanism, where a rejected Promise will propagate the error up the call stack. Observables also have error handling, but it's more flexible, allowing you to handle errors in a more granular way.

  4. Backpressure Observables can handle backpressure, which means they can handle situations where the producer of data is faster than the consumer. Promises do not have built-in backpressure handling.

  5. Reactivity Observables are designed to be reactive, meaning they can react to changes in the data stream. Promises are not reactive by design.

Use Promises when:

You need to handle a single asynchronous operation with a clear start and end. You don't need to handle multiple values or streams of data. You don't need to cancel the operation or handle backpressure.

Use Observables when:

You need to handle multiple values or streams of data over time. You need to cancel an operation or handle backpressure. You need to react to changes in the data stream.


In conclusion, Promises and Observables are both powerful tools for handling asynchronous data in JavaScript. While Promises are suitable for simple, one-time asynchronous operations, Observables are better suited for handling streams of data and reactive scenarios. By understanding the strengths and weaknesses of each, you can choose the right tool for your specific use case.

Remember, when in doubt, ask yourself:

  • Do I need to handle a single value or a stream of data?
  • Do I need to cancel the operation or handle backpressure?
  • Do I need to react to changes in the data stream?

Answering these questions will help you decide whether to use Promises or Observables in your JavaScript application.