Exploring the Power of RxJS Operators in Angular Observables
Published: 2023-06-20 15:20:02

## Exploring the Power of RxJS Operators in Angular Observables



Angular is a popular front-end web development framework used to build complex and dynamic web applications. It uses the reactive programming concept to handle asynchronous data streams. Reactive programming is a paradigm for handling events, where changes in one object can be propagated to other objects that depend on it. This paradigm makes use of observables, which are objects that emit values over time.



Observables are a key feature in Angular development. They enable developers to manage complex asynchronous data flows, synchronize events, and handle errors. RxJS is the library that provides us with the powerful tools to manipulate and transform observables. In this article, we will explore the power of RxJS operators and how they can be used to transform data streams in Angular observables.



### What are RxJS operators?



RxJS operators are functions that allow us to transform, filter, or combine observables. These functions allow us to manipulate the data emitted by an observable without modifying the observable itself. There are two main types of operators:




  - Pipeable operators: These operators are functions that return a new observable, resulting in a chain of operators (also known as a pipeline).

  - Creation operators: These operators create new observables from scratch.



RxJS has a vast collection of operators that can be used to manipulate data streams. We will discuss some of the commonly used operators below.



### Map



The map operator is used to transform each value emitted by an observable. It takes a function as an argument that defines the transformation logic. The map operator returns a new observable with the transformed values.



<pre><code>
import { from } from 'rxjs';
import { map } from 'rxjs/operators';

const numbers$ = from([1, 2, 3, 4, 5]);

const squaredNumbers$ = numbers$.pipe(
  map((num: number) => num ** 2)
);

squaredNumbers$.subscribe(console.log);
// Output: 1, 4, 9, 16, 25
</code></pre>

In the above example, we have created an observable that emits a sequence of numbers using the from operator. We have then used the map operator to transform each number to its square value.



### Filter



The filter operator is used to filter out values emitted by an observable based on a condition. It takes a function as an argument that defines the filtering logic. The filter operator returns a new observable with the filtered values.



<pre><code>
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const numbers$ = from([1, 2, 3, 4, 5]);

const evenNumbers$ = numbers$.pipe(
  filter((num: number) => num % 2 === 0)
);

evenNumbers$.subscribe(console.log);
// Output: 2, 4
</code></pre>

In the above example, we have created an observable that emits a sequence of numbers using the from operator. We have then used the filter operator to filter out only the even numbers.



### Tap



The tap operator is used to perform side effects on an observable without modifying the emitted values. It takes a function as an argument that defines the side-effects logic. The tap operator returns the same values emitted by the observable.



<pre><code>
import { from } from 'rxjs';
import { tap } from 'rxjs/operators';

const numbers$ = from([1, 2, 3, 4, 5]);

const evenNumbers$ = numbers$.pipe(
  filter((num: number) => num % 2 === 0),
  tap((num: number) => console.log(`Even number: ${num}`))
);

evenNumbers$.subscribe(console.log);
// Output: Even number: 2, Even number: 4, 2, 4
</code></pre>

In the above example, we have used the tap operator to log the even numbers emitted by the observable.



### SwitchMap



The switchMap operator is used to switch to a new observable based on the values emitted by the original observable. It takes a function as an argument that returns a new observable. The switchMap operator returns the values emitted by the new observable.



<pre><code>
import { fromEvent, from } from 'rxjs';
import { switchMap } from 'rxjs/operators';

const button = document.querySelector('button');
const click$ = fromEvent(button, 'click');

const numbers$ = from([1, 2, 3, 4, 5]);

const clickMapped$ = click$.pipe(
  switchMap(event => numbers$.pipe(
    map((num: number) => num ** event.target.value)
  ))
);

clickMapped$.subscribe(console.log);
</code></pre>

In the above example, we have used the switchMap operator to switch to a new observable that calculates the power of each number based on the button click value.



### Reduce



The reduce operator is used to reduce the values emitted by an observable to a single value. It takes a function as an argument that defines the reducing logic. The reduce operator returns a new observable with the reduced value.



<pre><code>
import { from } from 'rxjs';
import { reduce } from 'rxjs/operators';

const numbers$ = from([1, 2, 3, 4, 5]);

const sum$ = numbers$.pipe(
  reduce((acc: number, curr: number) => acc + curr, 0)
);

sum$.subscribe(console.log);
// Output: 15
</code></pre>

In the above example, we have used the reduce operator to calculate the sum of numbers emitted by the observable.



### Conclusion



Angular observables allow developers to handle complex asynchronous data streams in a reactive way. RxJS provides powerful tools in the form of operators to manipulate and transform observables. In this article, we have explored some of the commonly used RxJS operators and how they can be used in Angular observables. By learning and mastering these operators, developers can streamline the development process and create efficient and robust Angular applications.