How to handle asynchronous operations in Node JS

Asynchronous operations are a fundamental aspect of Node JS, as it is designed to be non-blocking and efficient. Handling asynchronous operations properly is important for building scalable and performant applications. Let's explore various techniques and best practices for handling asynchronous operations in Node JS.

Some key points to handle asynchronous operations effectively
Some key points to handle asynchronous operations effectively

Asynchronous operations

In Node JS, asynchronous operations allow us to perform tasks without blocking the main thread, enabling the application to handle multiple requests concurrently. These operations include reading/writing files, making HTTP requests, querying databases, and more.

Synchronous vs. Asynchronous
Synchronous vs. Asynchronous

Callbacks

Callbacks are the traditional way of handling asynchronous operations in Node JS. A callback function is passed as an argument to an asynchronous function and is executed when the operation completes.

index.js
example.txt
// Example: Reading a file using callbacks
const fs = require('fs');
fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading file:', err);
  } else {
    console.log('File content:', data);
  }
});

Callbacks can lead to callback hellCallback hell refers to the situation when multiple nested callbacks are used in asynchronous code, leading to reduced readability and maintainability., where multiple nested callbacks can make code hard to read and maintain. To lessen this, we can use named functions or libraries like the async.js to handle flow control.

Callback hell
Callback hell

Explanation

The engine consists of a call stack for synchronous code execution and a heap memory for dynamic memory allocation. In the web browser, there are additional web APIs like setTimeout. The event loop manages asynchronous operations by picking pending functions from the callback queue and executing them when the call stack is empty.

Promises

Promises help in solving the callback hell problem. A promise represents a value that may not be available yet but will be resolved in the future, either successfully with a value or unsuccessfully with an error.

index.js
example.txt
// Example: Reading a file using promises
const fs = require('fs').promises;
fs.readFile('example.txt', 'utf8')
  .then((data) => {
    console.log('File content:', data);
  })
  .catch((err) => {
    console.error('Error reading file:', err);
  });

Promises allow chaining and can be combined using the Promise.all or Promise.race.

Promises
Promises

Let's see the meaning of different states of promises.

States of promises

Promise state

Explanation

Pending

The initial waiting state

Fullfilled

Operation done successfully

Rejected

Operation failed

Async/Await

Async/Await makes asynchronous code look more like synchronous code. It provides a cleaner and more structured way to handle asynchronous operations.

index.js
example.txt
// Example: Reading a file using async/await
const fs = require('fs').promises;
async function readFileAsync() {
  try {
    const data = await fs.readFile('example.txt', 'utf8');
    console.log('File content:', data);
  } catch (err) {
    console.error('Error reading file:', err);
  }
}
readFileAsync();

Async functions return a Promise, allowing us to use them with Promise.all or other Promise-based APIs.

Event emitters

Node JS implements the Observer pattern through event emitters. Event emitters are objects that emit named events, and you can attach listeners to these events.

// Example: Using an Event Emitter
const EventEmitter = require('events');
const myEmitter = new EventEmitter();
myEmitter.on('myEvent', (data) => {
  console.log('Event data:', data);
});
myEmitter.emit('myEvent', { message: 'Hello, world!' });

Event emitters are commonly used in cases like handling HTTP requests, reading data from streams, or building custom modules.

Event Emitter
Event Emitter

Explanation

The flow depicted by the image is as follows:

  1. Event emitters (represented by the circles) are objects capable of triggering events.

  2. Other objects, such as listeners or subscribers (represented by the arrows pointing towards the circles), can register themselves to listen for specific events emitted by the event emitter.

  3. When a relevant event occurs, the event emitter notifies all registered listeners by calling their corresponding event handler functions.

  4. The event handlers (not shown in the image) are functions defined by the listeners, which respond to the specific events they are subscribed to.

  5. This flow allows for a decoupled and flexible communication mechanism, enabling different parts of the code to interact without directly depending on each other, promoting better maintainability and scalability in the application.

Concurrency with worker threads

Node JS provides worker threads to run JavaScript code in parallel in separate threads. This is useful for CPU-intensive tasks, but you should be careful, as it introduces complexities in managing shared states and can impact performance if used indiscriminately.

// Example: Using Worker Threads
const { Worker, isMainThread, parentPort } = require('worker_threads');
if (isMainThread) {
  const worker = new Worker(__filename);
  worker.on('message', (message) => {
    console.log('Worker says:', message);
  });
  worker.postMessage('Hello from the main thread!');
} else {
  parentPort.on('message', (message) => {
    console.log('Main thread says:', message);
    parentPort.postMessage('Hello from the worker thread!');
  });
}

The "Execution Timed Out!" message is not an error in the code but rather a limitation imposed by the specific environment where the code is being executed.

Parallel processing in Node JS using worker threads
Parallel processing in Node JS using worker threads

Handling errors

Proper error handling is important in asynchronous code. For Promises and Async/Await, use the try...catch blocks. For callbacks, ensure you handle errors properly in each callback function.

Conclusion

Asynchronous operations are a key aspect of Node JS development. By understanding and effectively handling asynchronous code using callbacks, promises, async/await, event emitters, and worker threads, you can build scalable and efficient Node JS applications.

1

Callback hell refers to:

A)

The excessive use of callbacks leading to reduced application performance.

B)

A situation where callbacks are nested deeply, leading to reduced readability and maintainability.

C)

A situation where callbacks are used instead of Promises.

D)

A situation where callbacks are used to handle file I/O operations.

Question 1 of 30 attempted

Free Resources

Copyright ©2025 Educative, Inc. All rights reserved