Node.js Interview Questions and Answers

Question: How do you handle errors in Node.js?

Answer:

Error handling in Node.js is crucial for ensuring that your application runs smoothly and gracefully handles unexpected situations. Since Node.js is asynchronous and event-driven, it requires a careful approach to error handling, especially in callbacks, promises, and event-driven systems. Here’s how you can handle errors in various scenarios in Node.js:

1. Callback-based Error Handling

In Node.js, many core modules and third-party libraries use a callback pattern where the first argument in the callback is often reserved for an error object. This is known as the error-first callback pattern.

• Pattern: If an error occurs, it’s passed to the callback as the first argument; otherwise, the second argument contains the result.

Example:

const fs = require('fs');

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading file:', err);
    return;
  }
  console.log('File contents:', data);
});

• If an error occurs while reading the file, the err argument will contain the error object, which you can check and handle appropriately.

2. Using try...catch for Synchronous Code

For synchronous code or code that might throw exceptions, you can use a try...catch block. This is ideal for catching errors that occur during execution, such as invalid operations or accessing undefined variables.

Example:

try {
  let result = someUndefinedFunction(); // This will throw an error
} catch (err) {
  console.error('Caught an error:', err.message);
}

• If an exception is thrown within the try block, it’s caught in the catch block, and you can handle it accordingly.

3. Handling Errors in Promises (with .catch())

For asynchronous operations that use Promises (like fetch, fs.promises, etc.), errors are caught by attaching a .catch() method to the Promise chain. You can also handle errors with async/await using try...catch.

Example with .catch():

const fs = require('fs').promises;

fs.readFile('file.txt', 'utf8')
  .then(data => {
    console.log('File contents:', data);
  })
  .catch(err => {
    console.error('Error reading file:', err);
  });

• If the fs.readFile() promise is rejected, the .catch() method will handle the error.

Example with async/await:

const fs = require('fs').promises;

async function readFile() {
  try {
    const data = await fs.readFile('file.txt', 'utf8');
    console.log('File contents:', data);
  } catch (err) {
    console.error('Error reading file:', err);
  }
}

readFile();

• With async/await, you can handle errors using a try...catch block, which is more readable and synchronous in appearance.

4. Global Error Handling with process.on()

For handling unhandled errors globally, you can use the process.on() method to listen for specific events like uncaughtException and unhandledRejection.

• uncaughtException: This event is emitted when an exception is thrown but not caught anywhere in the application.
• unhandledRejection: This event is emitted when a promise is rejected but no .catch() is attached.

Example:

// Handle uncaught exceptions globally
process.on('uncaughtException', (err, origin) => {
  console.error('Unhandled exception:', err);
  console.log('Exception origin:', origin);
  // Optionally shut down the application gracefully
  process.exit(1); // Exit with error code
});

// Handle unhandled promise rejections globally
process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
  // Optionally shut down the application gracefully
  process.exit(1);
});

• Warning: It’s important to note that uncaughtException and unhandledRejection are global event listeners, and it’s generally recommended to use them for logging and graceful shutdown. However, relying solely on these events for error handling is discouraged, as they could leave your application in an inconsistent state.

5. Handling Errors in Streams

Streams in Node.js (e.g., fs.createReadStream, http.createServer) emit an error event if something goes wrong. To handle these errors, you need to listen for the error event on the stream.

Example:

const fs = require('fs');
const readableStream = fs.createReadStream('file.txt');

readableStream.on('data', (chunk) => {
  console.log('Reading chunk:', chunk);
});

readableStream.on('error', (err) => {
  console.error('Error reading stream:', err);
});

• If an error occurs while reading the stream, the error event will be triggered, and you can handle it in the listener.

6. Custom Error Handling in Node.js

You can create custom error types by extending the built-in Error class. This allows you to handle different types of errors in a more structured way.

Example:

class CustomError extends Error {
  constructor(message, code) {
    super(message);
    this.name = 'CustomError';
    this.code = code;
  }
}

function throwCustomError() {
  throw new CustomError('Something went wrong!', 500);
}

try {
  throwCustomError();
} catch (err) {
  if (err instanceof CustomError) {
    console.error(`Custom error occurred: ${err.message} (code: ${err.code})`);
  } else {
    console.error('General error:', err.message);
  }
}

• Custom errors allow you to include additional properties (e.g., error codes) to make error handling more descriptive and structured.

7. Error-Handling Best Practices

• Graceful Shutdown: Ensure your application can gracefully shut down when critical errors occur, for example, when an uncaught exception is thrown or a critical promise rejection happens.
• Logging: Always log errors with enough context (e.g., stack traces, request details) to aid debugging.
• Error Propagation: In asynchronous code, always propagate errors to the caller. For Promises, always return a rejected promise or use .catch().
• Fail Fast: Catch errors early to prevent cascading failures. Use proper validation and checks before performing I/O operations, network requests, or other asynchronous tasks.

Conclusion:

Error handling in Node.js is essential for building robust and reliable applications. The best practices involve using error-first callbacks, try...catch for synchronous code, process.on() for global error handling, and handling errors in streams, promises, and custom error classes. By adopting these practices, you can ensure that your Node.js applications can gracefully handle errors and continue to function even in adverse conditions.

Question: What is the cluster module in Node.js?

Answer:

The cluster module in Node.js is a built-in module that allows you to take advantage of multi-core systems by creating child processes (workers) that can share the same server port. This is particularly useful for scaling Node.js applications to handle more traffic, as it enables parallelism and efficient use of CPU cores.

Node.js operates on a single thread and processes one request at a time. While this works well for I/O-bound operations, it can become a bottleneck for CPU-bound tasks. The cluster module helps by allowing Node.js to fork multiple worker processes, each with its own event loop, thus enabling parallel execution.

Key Concepts in the Cluster Module:

1. Master Process: The main process that manages worker processes. The master process is responsible for forking worker processes and distributing incoming requests to them.
2. Worker Process: Child processes that are created by the master process. Each worker runs in its own thread with a separate event loop and handles incoming requests independently.
3. IPC (Inter-Process Communication): Workers and the master process communicate with each other using IPC channels. This is used for monitoring worker status, handling errors, or sending messages.

How the Cluster Module Works:

• The master process forks multiple worker processes (equal to the number of CPU cores, for example) to handle incoming requests.
• Each worker is essentially a separate instance of your Node.js application, with its own memory and event loop, allowing Node.js to process multiple requests concurrently.
• Workers share the same server port, and the master process manages load balancing between them.

Example: Simple HTTP Server with Cluster Module

Here’s a basic example of how to use the cluster module to create a simple HTTP server that scales across multiple CPU cores:

Example Code:

const http = require('http');
const cluster = require('cluster');
const os = require('os');

// Get the number of CPU cores
const numCPUs = os.cpus().length;

// If the process is the master, fork workers
if (cluster.isMaster) {
  console.log(`Master process (PID: ${process.pid}) is running`);

  // Fork workers based on the number of CPU cores
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
  });
} else {
  // If the process is a worker, create an HTTP server
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`Hello, Node.js! This is worker ${process.pid}`);
  }).listen(8000, () => {
    console.log(`Worker ${process.pid} started`);
  });
}

How It Works:

1. The master process forks multiple worker processes (one for each CPU core). In this example, it forks workers based on the number of available CPU cores (os.cpus().length).
2. Each worker runs a separate HTTP server and listens on the same port (8000).
3. When a request is made, the master process balances the load between the workers. If one worker is busy or unavailable, others can handle the requests.
4. If a worker dies, the master process can detect it and fork a new worker to replace it.

Advantages of Using the Cluster Module:

1. Scalability: The cluster module allows your Node.js application to scale horizontally, making it more efficient on multi-core systems. This is especially useful for CPU-bound tasks, as each worker can run on a separate CPU core.
2. Load Balancing: The master process automatically load-balances incoming requests among the workers, which helps in handling more traffic without a significant performance hit.
3. Fault Tolerance: If a worker crashes, the master can detect it and fork a new one, helping the application stay resilient.

Use Cases:

1. High Traffic Websites/Applications: By using multiple workers, applications can handle a higher volume of concurrent HTTP requests.
2. CPU-Intensive Operations: For applications that perform heavy computations, clustering allows you to spread the load across multiple CPU cores.
3. Microservices Architecture: When implementing microservices with Node.js, clustering can help scale each microservice across multiple cores.

Best Practices:

• Graceful Shutdown: Implement a mechanism for workers to handle graceful shutdowns (e.g., clean up resources and close connections) before exiting.
• Cluster Communication: Use the process.send() and process.on('message', ...) methods to send messages between the master and worker processes.
• Error Handling: Handle errors within workers to avoid crashes. Consider using a process manager like PM2 for better management of cluster processes.

Conclusion:

The cluster module in Node.js is a powerful tool for scaling Node.js applications to take full advantage of multi-core systems. By forking multiple workers, you can handle more traffic and perform CPU-intensive tasks more efficiently. It enables parallelism, load balancing, and fault tolerance, making it an essential tool for building highly scalable and resilient Node.js applications.

Read More

If you can’t get enough from this article, Aihirely has plenty more related information, such as Node.js interview questions, Node.js interview experiences, and details about various Node.js job positions. Click here to check it out.