Async Unleashed: Mastering Callbacks and Promises in Node.js

Asynchronous or Async means things that can happen independently of the main flow. Asynchronous Code in Node.Js allow execution of task like database query, file I/O and network request without blocking the main thread.

This non-blocking behaviour is enabled by the Node Js Event loop, which manage concurrent operations with JavaScript, even through JavaScript is single threaded.

Why Async Code exist in Node Js

Async code is used because

• Node Js is commonly used for task like file operation, API Request and database query. This code is running background without blocking the main thread or the rest of the code.

• It follows an event loop structure where event loop listen for task and runs them only when it needed.

• It improves the performances as it does not effect the main thread.

• This makes the API call faster.

• Unlike multi thread model, Node Js useg the single threaded which optimizes CPU useg and memory use.

In Node Js there are many ways to handle async operations that are:

Callbacks

Callbacks are the function passes as an argument in a function.

Here is an example

function welcome(name, callbackFunction) {
    console.log("Hello ", name);
    callbackFunction();
}

function message() {
    console.log("Welcome to onboard!!");
}

welcome("John", message);

The output will become

Hello  John
Welcome to onboard!!

Here we can clearly see we pass a function reference of message to the function welcome and inside the welcome function we just call it.

Another example of callback can be

document.getElementById('button').addEventListener('click', () => {
  console.log("Button Clicked");
});

Why we don’t use it?

When the code becomes nested and unreadable then we should avoid to use callbacks. This phenomena is called callback hell. It creates unreadable, unmaintainable code with fragile error handling and complex debugging, resulting from deep, nested asynchronous operations.

It makes code hard to follow due to excessive indentation and prevents efficient parallel execution, forcing strict serial processing.

It makes the code

• Poor Readable

• Difficult to Maintenance

• Makes error handling complex

• Make debugging more difficult.

Here is an example code

// Example of Callback Hell
getData(function(a) {
    getMoreData(a, function(b) {
        getEvenMoreData(b, function(c) {
            getFinalData(c, function(d) {
                console.log(d);
            });
        });
    });
});

Promises

A Promise is a object that represent the outcome of an Asynchronous task. In other words a Promise is a placeholder value that will eventually be filled in the future. It is similar to real life promises, if someone make a promise to play cricket on the evening that is an assurance that the person will play cricket in the evening.

Promises allow an asynchronous operation to run and wait for the value while running any following code that is callbacks.

It uses .then() and .catch() keyword for applying promises. Here is a simple syntax:

firstFunction(args)
  .then(secondFunction(args))
  .then(thirdFunction(args))

Here is an simple example

// 1. Initialize: Create a new Promise 'container'
const myPromise = new Promise((resolve, reject) => {
  // Simulating a condition (e.g., a network check or calculation)
  const success = true;

  if (success) {
    // 2. Fullfill: Send data to the .then() block
    resolve("Done!");
  } else {
    // 3. Reject: Send an error to the .catch() block
    reject("Failed!");
  }
});

// --- Consuming the Promise ---
myPromise
  .then((value) => {
    // Executes only if resolve() was called
    console.log(value); 
  })
  .catch((err) => {
    // Executes only if reject() was called
    console.error(err);
  });

The output will be

Done!

Here another example

const orderCoffee = (flavor) => {
  return new Promise((resolve, reject) => {
    console.log(`Order placed: ${flavor}. Please wait...`);

    const isMachineWorking = true;

    setTimeout(() => {
      if (isMachineWorking) {
        resolve(`Your ${flavor} is ready!`);
      } else {
        reject("❌ Sorry, the coffee machine is broken.");
      }
    }, 3000); // 3-second delay
  });
};

// Using the Promise
orderCoffee("Cappuccino")
  .then((message) => console.log(message))
  .catch((error) => console.log(error));

The output will be like first it print Order placed: Cappuccino. Please wait… then after 3 second it prints Your Cappuccino is ready!

So the final Output is

Order placed: Cappuccino. Please wait...
Your Cappuccino is ready!

Benefits of promises

• It makes the code more readable.

• It centralized error handling using .catch() keyword.

• It helps in Parallel execution.

• It has a much more cleaner Integration of JavaScript code with modern syntax.

Final Thoughts

Async programming is the most modern and good practice in JavaScript, it helps to make the code modular and more readable. It helps us to make JavaScript do multiple task on simultaneously basis with the help of the single thread.

Reference Article

You can follow the following articles for more understanding

• https://nodejs.org/learn/asynchronous-work/javascript-asynchronous-programming-and-callbacks#javascript-asynchronous-programming-and-callbacks

• https://blog.postman.com/understanding-async-await-in-node-js/

• https://www.geeksforgeeks.org/node-js/asynchronous-patterns-in-node-js/

• https://www.w3schools.com/nodejs/nodejs\_async.asp

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async\_function

• https://www.w3schools.com/JS/js\_promise.asp

• https://www.geeksforgeeks.org/javascript/javascript-promise/

That's it, now you understand Asynchronous Code in JavaScript. I’d love to hear your thoughts and feedbacks.

Thank You for your patients. ❤️