When exploring Reactive Programming in JavaScript, two concepts that frequently appear are BehaviorSubject and Observable. Understanding the difference between them is critical for grasping the complexities of reactive programming. In this post, we’ll look at the distinctions between BehaviorSubject and Observable to help you decide whether to use either.


An Observable is like a stream of events or data that you can subscribe to and react to when something happens. It represents a stream of data that can emit multiple values over time. Think of it as a sequence of events or values that arrive asynchronously, such as user input events, HTTP responses, or WebSocket messages.

For example, you sign up to receive notifications from a store about their weekly discounts. As long as you’re signed up, you’ll receive each week’s new discount. But if you sign up late, you’ll miss the previous weeks’ discounts.

Creating an Observable

import { Observable } from 'rxjs';

// Create an Observable that emits a sequence of values
const myObservable = new Observable(observer => {

Subscribing to an Observable

// Subscribe to the Observable
 value => console.log(`Next value: ${value}`),
 error => console.error(`Error: ${error}`),
 () => console.log('Complete!')
// Output: Next value: 1
// Output: Next value: 2
// Output: Next value: 3
// Output: Complete!

Using Operators

import { of, map } from 'rxjs';

// Create an Observable from an array
const numbers = of(1, 2, 3, 4, 5);

// Use the map operator to double each value
const doubledNumbers = numbers.pipe(
 map(value => value * 2)

// Subscribe to the transformed Observable
doubledNumbers.subscribe(value => console.log(value));
// Output: 2
// Output: 4
// Output: 6
// Output: 8
// Output: 10


A BehaviorSubject is like a value holder that always has the latest value, and anyone who asks can get it instantly. A BehaviorSubject is a type of Observable that has some special characteristics. While a regular Observable emits a sequence of values over time, a BehaviorSubject keeps track of the current value and ensures that any new observer immediately receives that value, even if they subscribe after the BehaviorSubject has already started emitting values.

For example, you subscribe to receive the current weather conditions. As soon as you subscribe, you get the latest weather report. From then on, you’ll receive updates whenever the weather changes.

Creating a BehaviorSubject

To create a BehaviorSubject, you need to import it from the RxJS library and provide an initial value:

import { BehaviorSubject } from 'rxjs';
const myBehaviorSubject = new BehaviorSubject(initialValue);

Subscribing to a BehaviorSubject

Subscribing to a BehaviorSubject works similarly to subscribing to a regular Observable:

 value => console.log(`Received value: ${value}`),
 error => console.error(`Error: ${error}`),
 () => console.log('BehaviorSubject completed')

Updating the BehaviorSubject

You can update the value of a BehaviorSubject using the next method, which will emit the new value to all subscribed observers:

When to Use Each?

Understanding which one to use in a given situation can make your code cleaner and more efficient.

Use Observables when:

  • You’re dealing with things that happen one after another over time, like tracking a user’s clicks on a website.
  • You need to combine or transform the incoming values in some way.
  • For example, you could use an Observable to track user input from a form field, where each keystroke is a new value in the stream.
  • Observables are perfect for event streams, HTTP requests, or whenever you need to handle asynchronous sequences of data over time.

Use BehaviorSubjects when:

  • You need to get the latest value immediately, like showing a user’s profile information as soon as they log in.
  • You have multiple parties that need to be notified of the latest value, like components on a page.
  • Common use cases include sharing data across components, global state management, and representing values that change over time but need an initial value.
  • You’re keeping track of some state or data that can change over time, like items in a shopping cart.
  • Imagine you’re building a shopping cart application. A BehaviorSubject could be used to represent the current state of the cart, ensuring that any new component that needs to display the cart contents immediately has access to the latest data.

In easy words, if you’re building a chat app where new messages constantly arrive, use Observables. But if you’re making a status indicator that always shows the current status, go for BehaviorSubject.


In summary, Observables are like ongoing streams of events or data that you can subscribe to and react to over time, while BehaviorSubjects are like instant value holders that always have the latest value ready for anyone who asks. Both are essential concepts in reactive programming, helping us handle dynamic data and events effectively in everyday scenarios.

Support On Demand!