switchMap in RxJS

As the name suggest, the SwitchMap operator of rxjs is used to switch between emission. It switches from one observable to the other observable by cancelling the previous observable and switches to the new observable.

In this example, we shall see how to switch between different api call.

Lets create an angular application using the angular cli command.

ng new switchmap-tutorial

Lets create a service to make http api call. Enter the following angular cli command to create a service.

ng g s services/http

Now open the file and modify the code as below.

import { Injectable } from '@angular/core';
import { HttpClient} from '@angular/common/http';
import { Observable} from 'rxjs';
​
@Injectable({
  providedIn: 'root'
})
export class HttpService {
​
  constructor(private http: HttpClient) {
  }
​
  getCall(url: string): Observable<any> {
    return this.http.get(url);
  }
}
​

Now create a service using the below angular cli command.

ng g s services/rxjs

This will create us a service in the services folder. Now open the rxjs.service.ts file and add the following code.

import { Injectable } from '@angular/core';
import { from } from 'rxjs';
import { switchMap} from 'rxjs/operators';
import { HttpService } from '../services/http.service';
@Injectable({
  providedIn: 'root'
})
export class RxjsService {
​
  domainUrl = 'https://reqres.in/api/users?page=';
  reqArray = [1, 2, 3, 4, 5];
  constructor(private httpService: HttpService) { }
​
  switchMapCall() {
    from(this.reqArray).pipe(
      switchMap(id => this.httpService.getCall(this.domainUrl + id))
    ).subscribe((value) => {
      console.log(value);
    });
  }
}
​

Here we have create a variable domainUrl to hold base url and reqArrayvariable to hold the array of integers to make api call by appending to the above url.

We create a function with the name switchMapCall and inside the function we use the from rxjs operator which is used to convert an array to an observable. Here we give the reqArray array variable as parameter to the from operator, which will be piped and given to the switchMap operator one by one.

The switchMap operator gets the integers in the array one by one in the idparameter and then it appends the id to the domainUrl and makes an api call. But before the api call returns the result the next integer will be piped and passed to the switchMap, which now cancels the previous api call and forms new url with 2 as id value and makes api. In the meantime, the value 3is passed to the id parameter and the previous api call will be cancelled. Similar thing will happen continously and only the final api call with id value of '5' will be successful.

Open the app.component.ts file and modify the code as below.

import { Component, OnInit } from '@angular/core';
import { RxjsService } from './services/rxjs.service';
​
@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css'],
})
export class AppComponent implements OnInit {
​
  constructor(private rxjsService: RxjsService) {
  }
 
  ngOnInit(): void {
    this.rxjsService.switchMapCall();
  }
}
​

Now run your application and press the F12 key to open the debugger option and select the networks tab and check out.

You will notice only the final api call will be successful and the rest of the calls gets cancelled.

What if suppose you want to call an api and use its result to make another api. Some of them will come up with the solution of subscribing inside another subscribe function. Thats not a good practise to work with. Lets see how to use switchMap to solve the problem.

Open the rxjs.service.ts file and add modify the code as below.

import { Injectable } from '@angular/core';
import { from, throwError } from 'rxjs';
import { switchMap, catchError } from 'rxjs/operators';
import { HttpService } from '../services/http.service';
@Injectable({
  providedIn: 'root'
})
export class RxjsService {
​
  domainUrl = 'https://reqres.in/api/users?page=';
  reqArray = [1, 2, 3, 4, 5];
  constructor(private httpService: HttpService) { }
​
  switchMapCall() {
    from(this.reqArray).pipe(
      switchMap(id => this.httpService.getCall(this.domainUrl + id))
    ).subscribe((value) => {
      console.log(value);
    });
​
  }
​
  syncSwitchMapCall() {
    this.httpService.getCall(this.domainUrl + '1').pipe(
      switchMap((result1) => {
        console.log(result1);
        // Can process something with the result obtained in result1.
        return this.httpService.getCall(this.domainUrl + '2');
      }),
      switchMap((result2) => {
        console.log(result2);
        // Can process something with the result obtained in result2.
        return this.httpService.getCall(this.domainUrl + '3');
      }),
      catchError((error) => {
        return throwError(error);
      })
    ).subscribe((result3) => {
      // Finally, result will be returned only for 3rd api call.
      console.log(result3);
    }, (error) => {
      console.log(`Error occured`, error);
    });
  }
}
​

Here we have added the additional function with the name syncSwitchMapCall. This function will call a url initially and pipes the result and gives it to a switchMap operator. This operator will get the result and logs it to the console and makes the second call and returns the observable to the second switchMap operator. Now it holds the result of the second api call. If we need to get the value from it we can get it from 'result2' variable. Now the second switchMap calls the third api call and returns the observable.

This observable will be subscribed and the final result will be logged to the console. If any error occurs, it will be catched by the catchError and it throws the error. The error will be caught by the second callback function of subscribe function.

Now open the app.component.ts file and instead of calling switchMapCallfunction call the syncSwitchMapCall function.

import { Component, OnInit } from '@angular/core';
import { RxjsService } from './services/rxjs.service';
​
@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css'],
})
export class AppComponent implements OnInit {
​
  constructor(private rxjsService: RxjsService) {
  }
 
  ngOnInit(): void {
    this.rxjsService.syncSwitchMapCall();
  }
}
​

Run your application and press F12 and check the Console and Network tab. It looks as below.

Working with Node.js streams

Introduction Streams are one of the major features that most Node.js applications rely on, especially when handling HTTP requests, reading/writing files, and making socket communications. Streams are very predictable since we can always expect data, error, and end events when using streams. This article will teach Node developers how to use streams to efficiently handle large amounts of data. This is a typical real-world challenge faced by Node developers when they have to deal with a large data source, and it may not be feasible to process this data all at once. This article will cover the following topics: Types of streams When to adopt Node.js streams Batching Composing streams in Node.js Transforming data with transform streams Piping streams Error handling Node.js streams Types of streams The following are four main types of streams in Node.js: Readable streams: The readable stream is responsible for reading data from a source file Writable streams: The writable stream is re...

NEW TECH UPDATES

Search This Blog

switchMap in RxJS

Comments

Post a Comment

Popular posts from this blog

4 Ways to Communicate Across Browser Tabs in Realtime

Certbot SSL configuration in ubuntu

Working with Node.js streams