Angular Observable Tutorial

Angular is a popular JavaScript framework that enables developers to build dynamic web applications with ease. One of the key features of Angular is the use of observables, which allow developers to create asynchronous code that can handle events, streams of data, and more. In this tutorial, we will explore Angular observables and how they can be used in building applications.

What are Observables in Angular?

Observables are a new way of handling asynchronous code in Angular. Instead of relying on callbacks or promises, observables use a stream-based approach to handle the flow of data. This turns out to be an effective and efficient way of handing events and data streams in large-scale applications.

The Anatomy of an Observable

At their core, observables are simple functions that define a stream of values that can be observed. This stream can be anything, an event, an array, or even an HTTP call to the server. The observable is defined as a function that receives an observer as an input. The observer has three methods that can be used to handle the stream of data, namely next(), error(), and complete().

import { Observable } from ‘rxjs’;

const observable = new Observable((observer) => {‘Hello, World!’);

In the example above, we have defined a simple observable that emits a single value, ‘Hello, World!’. We then call the complete() method, which signals that the stream of data has completed. In this case, because we only have one value, the stream completes immediately.

Observable Operators

The true value of observables comes from the numerous operators they provide that can be used to transform, filter, and combine streams of data. These operators can be easily chained together in a declarative way to create complex observable flows.

One of the most commonly used operators is the map() operator, which is used to transform the data emitted by the observable. Here’s an example:

import { from } from ‘rxjs’;
import { map } from ‘rxjs/operators’;

const observable = from([1, 2, 3, 4, 5]).pipe(
map((value) => value + 1)

observable.subscribe((data) => {
console.log(data); // Outputs 2,3,4,5,6

In this example, we are creating an observable from an array of numbers. We then use the map() operator to add 1 to each value. When we subscribe to the observable, we receive the transformed values in the observer’s next() method.

Using Observables for HTTP Requests

Another common use case for observables in Angular is for making HTTP requests. Angular provides a built-in HTTP module that allows developers to make requests and handle responses as observables. Here’s an example:

import { HttpClient } from ‘@angular/common/http’;

constructor(private http: HttpClient) {}

this.http.get(‘’).subscribe((data) => {

In this example, we are making an HTTP GET request to the URL provided and subscribing to the resulting observable. The data returned from the HTTP request is emitted by the observable and logged to the console.


What’s the difference between an Observable and a Promise?

Both observables and promises are used to handle asynchronous code, but they differ in their approach. Promises are a single value that is resolved or rejected, whereas observables emit multiple values over time. Observables also provide powerful operators that can be used to transform, filter, or combine streams of data, making them better suited for handling complex applications.

How can I unsubscribe from an Observable?

Observables can emit data indefinitely, which can cause a memory leak if not properly handled. To unsubscribe from an observable, you can use the unsubscribe() method. This method is automatically called when the observable completes, but it’s always a good practice to manually unsubscribe when no longer needed.

Can I use Observables in place of Promises?

Yes, observables can be used in place of promises in many cases. Observables provide more functionality and flexibility, making them a better choice for complex applications. However, promises are still a viable option for simple, one-time async tasks.

What are some common use cases for Observables in Angular?

Observables can be used for a variety of use cases in Angular. Some of the most common use cases include handling user input events, making HTTP requests, handling animations, and managing state across components.

How can I debug Observables?

Debugging observables can be difficult because they are asynchronous and reactive. However, Angular provides a number of tools for debugging. You can use the Angular DevTools extension for Chrome or Firefox, which allows you to inspect and debug observables. You can also use the RxJS debugging tools, which provide observables-specific debugging features like logging and tracing.


Observables are an important part of the Angular framework and provide a powerful way to handle asynchronous programming. With observables, you can handle streams of data in a more reactive and efficient way, making it easier to build complex applications. By using operators like map(), filter(), and combineLatest(), you can create powerful observable flows that can handle events, data streams, animations, and more. By understanding the basics of observables, you can take your Angular development to the next level and create more dynamic and scalable applications.

Similar Posts