Explain Async Await with Promises in Node.js

Async/Await in Node.js is a powerful way to handle asynchronous operations. It allows you to write asynchronous code in a synchronous manner, making it easier to read, write, and debug. This feature is built on top of Promises, which represent a value that may be available now, or in the future, or never.

To use async-await, we just need to create an async function in which we will implement our try-catch block. In the try block, we will await our promise to be completed. If it gets resolved we will get the result otherwise an error will be thrown through the catch block. Await can only be used inside an async function or async callback or async arrow function.

Introducing Async/Await

Async/Await is syntactic sugar built on Promises, allowing you to write asynchronous code as if it were synchronous, using async functions and the await keyword.

Async Function

An async function is a function declared with the async keyword. It always returns a Promise. If the function returns a value, the Promise resolves with that value; if the function throws an exception, the Promise rejects with the thrown value.

Await Keyword

The await keyword can only be used inside an async function. It pauses the execution of the function until the Promise is resolved or rejected.

const fetchData = () => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            const data = { id: 1, name: 'Jane Doe' };
            resolve(data);
        }, 2000);
    });
};

const getData = async () => {
    try {
        const data = await fetchData();
        console.log('Data received:', data);
    } catch (error) {
        console.error('Error:', error);
    }
};

getData();

Advantages of Async/Await

• Simpler Syntax: Async/Await allows you to write asynchronous code in a synchronous-like manner, making it easier to understand and maintain.
• Error Handling: Use try/catch blocks to handle errors, just like synchronous code.
• Improved Readability: Code that uses Async/Await is often more readable than code that chains multiple .then() calls.

Fetching Data from an API

const fetch = require('node-fetch');

const fetchUser = async (userId) => {
    try {
        const response = await fetch(`https://jsonplaceholder.typicode.com/users/${userId}`);
        const user = await response.json();
        console.log('User:', user);
    } catch (error) {
        console.error('Error fetching user:', error);
    }
};

fetchUser(1);

Here, fetchUser is an async function that waits for the fetch operation to complete and then processes the response.

Chaining Async Operations

const fetch = require('node-fetch');

const fetchPost = async (postId) => {
    const response = await fetch(`https://jsonplaceholder.typicode.com/posts/${postId}`);
    return response.json();
};

const fetchUser = async (userId) => {
    const response = await fetch(`https://jsonplaceholder.typicode.com/users/${userId}`);
    return response.json();
};

const getPostAndUser = async (postId, userId) => {
    try {
        const post = await fetchPost(postId);
        const user = await fetchUser(userId);
        console.log('Post:', post);
        console.log('User:', user);
    } catch (error) {
        console.error('Error:', error);
    }
};

getPostAndUser(1, 1);

This above syntax demonstrates chaining multiple asynchronous operations using Async/Await.

Steps to Setup Project

Step 1: Make a folder structure for the project.

mkdir myapp

Step 2: Navigate to the project directory

cd myapp

Step 3: Initialize the NodeJs project inside the myapp folder.

npm init -y

Project Structure:

Example: Implementation to explain async await with promises.

// app.js

const mod = (a, b) => {
    return new Promise((resolve, reject) => {
        if (b == 0) {
            // Rejected (error)
            reject("Modulo zero is not allowed");
        } else {
            // Resolved (Success)
            resolve(a % b);
        }
    });
};

// 5 mod 2 will give result 1
async function _5mod2() {
    try {
        const res = await mod(5, 2);
        console.log(`The result of division is ${res}`);
    } catch (err) {
        console.log(err);
    }
};
_5mod2();

// 5 mod 0 will give error
async function _5mod0() {
    try {
        const res = await mod(5, 0);
        console.log(`The result of division is ${res}`);
    } catch (err) {
        console.log(err);
    }
};
_5mod0();

The result of division is 1
Modulo zero is not allowed