Top 25+ Node.js Interview Questions & Answers | Your Personalized AI Guide

The package.json file is a crucial part of any Node.js project. It serves several purposes:

• Metadata: Contains metadata about the project, such as its name, version, description, and author.
• Dependencies: Lists the project dependencies, specifying which packages and versions are required.
• Scripts: Defines scripts that can be run with npm, such as start, test, and build scripts.
• Configuration: Provides a place for configuration options for various modules.

Middleware in Express.js are functions that execute during the lifecycle of a request to the server. They can perform various tasks, such as logging, authentication, parsing, and more. Middleware functions have access to the request object ( req ), the response object ( res ), and the next middleware function in the application’s request-response cycle.

Example of middleware:

const express = require('express');
const app = express();

const myMiddleware = (req, res, next) => {
  console.log('Middleware executed');
  next(); // Pass control to the next middleware
};

app.use(myMiddleware);
app.get('/', (req, res) => {
  res.send('Hello World');
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

Both process.nextTick() and setImmediate() are used to schedule callbacks in Node.js, but they operate differently:

• process.nextTick(): Schedules a callback to be invoked in the current iteration of the event loop, before any I/O operations.

process.nextTick(() => {
  console.log('Executed in the current iteration');
});

• setImmediate(): Schedules a callback to be executed in the next iteration of the event loop, after I/O events.

setImmediate(() => {
  console.log('Executed in the next iteration');
});

The buffer module in Node.js is used to handle binary data. Buffers are fixed-size chunks of memory outside the V8 heap. They are primarily used for:

• Manipulating binary data: Allows reading and writing of binary data streams.
• Handling file I/O: Works efficiently with file and network I/O operations.
• Encoding conversions: Converts between different encodings, such as UTF-8, Base64, and more.

Example of creating a buffer:

const buffer = Buffer.from('Hello World');
console.log(buffer); // 

Asynchronous code in Node.js can be handled in several ways:

• Callbacks: Functions passed as arguments to be executed after a certain operation.

fs.readFile('file.txt', (err, data) => {
  if (err) throw err;
  console.log(data);
});

• Promises: Objects representing the eventual completion or failure of an asynchronous operation.

fs.promises.readFile('file.txt')
  .then(data => console.log(data))
  .catch(err => console.error(err));

• Async/Await: Syntactic sugar built on top of promises, making asynchronous code look synchronous.

async function readFile() {
  try {
    const data = await fs.promises.readFile('file.txt');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}
readFile();

Node.js modules can be categorized into three types:

• Core Modules: Built-in modules that come with Node.js, such as http , fs , path , url , etc. They can be included without specifying a path.

const http = require('http');

• Local Modules: Custom modules created by the user within their project. They are included by specifying a relative path.

const myModule = require('./myModule');

• Third-party Modules: Modules that are available through npm and can be installed using the npm package manager. They are included by specifying the module name.

const express = require('express');

Managing dependencies in a Node.js project involves using the Node Package Manager (NPM) or Yarn. Here's how you can manage dependencies:

1. Initializing a Project: Start by creating a package.json file to keep track of your project dependencies and metadata.

npm init

2. Installing Dependencies: Use npm install (or npm i ) to install dependencies. This command adds the dependencies to the node_modules directory and updates the package.json and package-lock.json files.

npm install express

3. Saving Dependencies: By default, dependencies are saved in the dependencies section of package.json . Use the --save-dev flag to save them as development dependencies.

npm install mocha --save-dev

4. Updating Dependencies: Keep your dependencies up-to-date by running the update command.

npm update

5. Removing Dependencies: Remove a dependency using the npm uninstall command, which also updates the package.json file.

npm uninstall express

6. Versioning: Specify the version of a dependency in the package.json file. Use semantic versioning to manage versions.

"dependencies": {
  "express": "^4.17.1"
}

7. Global vs Local Dependencies:

• Local Dependencies: Installed within the project directory and listed in package.json .
• Global Dependencies: Installed system-wide and used across multiple projects.

npm install -g nodemon

8. Lock Files:

• package-lock.json: Ensures consistent dependency versions across different installations by locking the exact versions of dependencies.

By managing dependencies effectively, you ensure that your Node.js project has all the necessary modules and their correct versions, making it easier to maintain and deploy.

The cluster module allows the creation of child processes (workers) that share the same server port. This helps in taking advantage of multi-core systems, improving the performance and scalability of Node.js applications. Each worker can handle incoming requests, balancing the load across multiple processes.

Example of using the cluster module:

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
  });
} else {
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Hello World');
  }).listen(8000);
}

The path module in Node.js provides utilities for working with file and directory paths. It is used to handle and transform file paths across different operating systems.

Common methods in the path module include:

• path.join([...paths]): Joins multiple path segments into one path.

const path = require('path');
const fullPath = path.join('/users', 'john', 'docs', 'file.txt');
console.log(fullPath); // Output: '/users/john/docs/file.txt'

• path.resolve([...paths]): Resolves a sequence of paths into an absolute path.

const absolutePath = path.resolve('users', 'john', 'docs', 'file.txt');
console.log(absolutePath); // Output: '/current/working/directory/users/john/docs/file.txt'

• path.basename(path, [ext]): Returns the last portion of a path.

const fileName = path.basename('/users/john/docs/file.txt');
console.log(fileName); // Output: 'file.txt'

• path.dirname(path): Returns the directory name of a path.

const dirName = path.dirname('/users/john/docs/file.txt');
console.log(dirName); // Output: '/users/john/docs'

• path.extname(path): Returns the extension of the path.

const extName = path.extname('/users/john/docs/file.txt');
console.log(extName); // Output: '.txt'

The path module ensures that the file paths are handled correctly, avoiding issues caused by different operating system path conventions.

Synchronous Functions: These functions block the execution of the code until they complete. They run sequentially and are simpler but can be inefficient for I/O operations.

const data = fs.readFileSync('file.txt', 'utf8');
console.log(data); // This will block until the file is read

Asynchronous Functions: These functions do not block the execution. They run in the background and use callbacks, promises, or async/await to handle the results. They are more efficient for I/O operations and allow the program to continue executing other tasks while waiting for the operation to complete.

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data); // This will execute after the file is read
});

The eventEmitter module in Node.js is used to handle asynchronous events. It allows objects to emit named events and handle functions that respond to those events (listeners). This module is part of the events module.

Example of using eventEmitter:

const EventEmitter = require('events');
class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();
myEmitter.on('event', () => {
  console.log('An event occurred!');
});
myEmitter.emit('event'); // Outputs: An event occurred!

Both Promises and Observables are used to handle asynchronous operations, but they have some key differences:

1. Promises:

• Single Value: A Promise resolves or rejects a single value.
• Eager Execution: A Promise starts executing immediately when it is created.
• Not Cancellable: Once created, a Promise cannot be cancelled.
• API Methods: then() , catch() , finally() .

const promise = new Promise((resolve, reject) => {
  // asynchronous operation
});

promise.then(value => {
  // handle resolved value
}).catch(error => {
  // handle error
});

2. Observables:

• Multiple Values: An Observable can emit multiple values over time.
• Lazy Execution: An Observable does not start emitting values until it is subscribed to.
• Cancellable: Observables can be cancelled using unsubscribe() .
• API Methods: subscribe() , unsubscribe() , operators like map , filter , merge .

import { Observable } from 'rxjs';

const observable = new Observable(observer => {
  // asynchronous operation
  observer.next(value);
  observer.complete();
});

const subscription = observable.subscribe({
  next(value) {
    // handle emitted value
  },
  error(err) {
    // handle error
  },
  complete() {
    // handle completion
  }
});

// To cancel the subscription
subscription.unsubscribe();

process.env is an object in Node.js that contains the user environment variables. It is used to access environment variables in a Node.js application. This is useful for storing configuration details such as database credentials, API keys, and other sensitive information outside the source code.

Example of using process.env :

// Set environment variables (usually done in a .env file or server configuration)
process.env.DB_HOST = 'localhost';
process.env.DB_USER = 'root';
process.env.DB_PASS = 'password';

// Access environment variables
const dbHost = process.env.DB_HOST;
const dbUser = process.env.DB_USER;
const dbPass = process.env.DB_PASS;

console.log(`Database host: ${dbHost}`);
console.log(`Database user: ${dbUser}`);

Microservices is an architectural style that structures an application as a collection of small, loosely coupled, independently deployable services. Each service is responsible for a specific functionality and communicates with other services over a network, typically through HTTP/REST or messaging protocols.

Node.js is well-suited for microservices because:

• Lightweight and Fast: Its non-blocking I/O and event-driven architecture make it ideal for handling multiple requests efficiently.
• Modular: Node.js encourages modular code, making it easier to split functionality into microservices.
• Scalable: Can easily scale horizontally by adding more instances.
• Large Ecosystem: The vast number of available modules and tools, like Express, make it easy to develop microservices.

Creating a RESTful API using Express involves defining routes for different HTTP methods (GET, POST, PUT, DELETE) and implementing the corresponding handlers.

Example of creating a simple RESTful API:

const express = require('express');
const app = express();
app.use(express.json()); // Middleware to parse JSON request bodies

// In-memory data store
let items = [{ id: 1, name: 'Item 1' }];

// GET all items
app.get('/items', (req, res) => {
  res.json(items);
});

// GET an item by ID
app.get('/items/:id', (req, res) => {
  const item = items.find(i => i.id === parseInt(req.params.id));
  if (!item) return res.status(404).send('Item not found');
  res.json(item);
});

// POST a new item
app.post('/items', (req, res) => {
  const item = { id: items.length + 1, name: req.body.name };
  items.push(item);
  res.status(201).json(item);
});

// PUT update an item by ID
app.put('/items/:id', (req, res) => {
  const item = items.find(i => i.id === parseInt(req.params.id));
  if (!item) return res.status(404).send('Item not found');
  item.name = req.body.name;
  res.json(item);
});

// DELETE an item by ID
app.delete('/items/:id', (req, res) => {
  const itemIndex = items.findIndex(i => i.id === parseInt(req.params.id));
  if (itemIndex === -1) return res.status(404).send('Item not found');
  items.splice(itemIndex, 1);
  res.status(204).send();
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});