100 Node.

js Interview Questions

1. What is Node.js, and how does it work?

Node.js is an open-source, cross-platform runtime environment that allows you to execute
JavaScript code outside a browser. It is built on the V8 JavaScript engine (the same engine
that powers Google Chrome), which compiles JavaScript into highly efficient machine code.

Node.js uses an event-driven, non-blocking I/O model, making it ideal for building scalable
and high-performance applications, such as web servers, APIs, and real-time applications. It
works by using a single-threaded event loop to handle multiple concurrent requests without
creating separate threads for each one.

2. Explain the difference between JavaScript in the browser and

Node.js.
Feature JavaScript in the Browser Node.js

Environment Runs in a browser Runs in a server environment

environment

Global window global

Object

APIs DOM manipulation, fetch File system, HTTP, Streams

API

Modules import/export require (CommonJS) or ES Modules

Purpose Frontend user interfaces Backend, server-side scripting

Runtime Limited to browser-specific Built for I/O-heavy tasks like file access or network
tasks communication

3. What is the purpose of the package.json file?

1/105
The package.json file is a configuration file for a Node.js project. It serves several purposes:

Metadata: Contains project details like name, version, author, and description.

Dependencies: Lists the packages the project depends on.

Scripts: Defines custom commands for development (e.g., start , test ).

Engines: Specifies the Node.js version the project supports.

Example:

json

{
"name": "my-app",
"version": "1.0.0",
"scripts": {
"start": "node index.js",
"test": "jest"
},
"dependencies": {
"express": "^4.18.2"
}
}

4. How do you install a package using npm?

To install a package using npm (Node Package Manager):

1. Open a terminal.

2. Run the command:

For a specific package: npm install <package-name>

To install globally: npm install -g <package-name>

To save it as a dependency: npm install <package-name> (default adds to

dependencies in package.json )

To save it as a development dependency: npm install <package-name> --save-

dev

2/105
5. How do you initialize a new Node.js project?
1. Open a terminal and navigate to the project directory.

2. Run the command:

bash

npm init

You’ll be prompted to fill out details like project name, version, etc.

3. Alternatively, use npm init -y to skip the prompts and create a package.json file with
default values.

6. What is a module in Node.js?

A module in Node.js is a reusable block of code that can be exported and imported into
other files. Node.js organizes code into modules to improve maintainability, modularity, and
reusability.

Types of modules:

1. Built-in modules: Predefined modules like fs , http , os .

2. Third-party modules: Installed via npm (e.g., express , lodash ).

3. Custom modules: User-defined modules created within a project.

7. How do you import and export modules in Node.js?

Exporting a module: Use module.exports for CommonJS syntax or export for ES
Modules.

javascript

// CommonJS
module.exports = { greet: () => console.log("Hello") };

3/105
 // ES Modules
export const greet = () => console.log("Hello");

Importing a module:

javascript

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

// ES Modules
import { greet } from './myModule.js';
greet();

8. What is the require function in Node.js?

The require function is used to import modules in Node.js. It loads a module and returns
its exported objects or functions. Commonly used with CommonJS modules.

Example:

javascript

const fs = require('fs'); // Import built-in module

const customModule = require('./customModule'); // Import custom module

9. How do you check the installed version of Node.js?

To check the installed version of Node.js:

1. Open a terminal or command prompt.

2. Run the command:

bash

4/105
 node -v

This will display the installed Node.js version (e.g., v18.16.0 ).

10. Explain the purpose of the process object in Node.js.

The process object in Node.js is a global object that provides information about and control
over the current Node.js process. It is part of the events module and is always available.

Key features:

Environment variables: Accessed via process.env .

Current directory: process.cwd() .

Arguments: Command-line arguments are available in process.argv .

Exit the process: process.exit() .

Signal events: Allows listening to system signals like SIGINT .

Example:

javascript

console.log(`Current directory: ${process.cwd()}`);

console.log(`Node.js version: ${process.version}`);
console.log(`Environment: ${process.env.NODE_ENV}`);

11. What is the difference between readFile and readFileSync ?

Feature readFile readFileSync

Type Asynchronous (non-blocking) Synchronous (blocking)

Execution Uses callbacks or Promises for Pauses execution until the file is read
completion

Performance Suitable for high-performance Suitable for small tasks or scripts

applications

Example

Code
Example

5/105
 Feature readFile readFileSync

```javascript ```javascript

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

fs.readFile('example.txt', 'utf8', (err, const data = fs.readFileSync('example.txt',

data) => { 'utf8');

if (err) console.error(err); console.log(data);

else console.log(data); ```

});

12. What is the purpose of the path module?

The path module in Node.js provides utilities for working with file and directory paths in a
cross-platform way. It handles path manipulations, ensuring compatibility across different
operating systems (e.g., Windows and Linux).

Common Uses:

Normalize file paths ( path.normalize ).

Join multiple segments into a single path ( path.join ).

Resolve absolute paths ( path.resolve ).

Extract file information (e.g., path.basename , path.extname ).

Example:

javascript

const path = require('path');

console.log(path.join( dirname, 'file.txt')); // Joins current directory with
'file.txt'
console.log(path.extname('file.txt')); // Outputs: '.txt'

13. How do you create a simple HTTP server in Node.js?

6/105
You can use the built-in http module to create an HTTP server.

Example:

javascript

const http = require('http');

const server = http.createServer((req, res) => {

res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Hello, world!\n');
});

server.listen(3000, () => {
console.log('Server is running on http://localhost:3000');
});

http.createServer creates the server.

res.writeHead sets the response status and headers.

server.listen starts the server on a specified port.

14. What is an event loop in Node.js?

The event loop is a core concept in Node.js. It allows Node.js to handle multiple concurrent
operations without creating multiple threads. It is part of Node.js's non-blocking I/O model.

How It Works:

1. Incoming requests or events are placed in a queue.

2. The event loop processes these events sequentially, executing the associated callback
functions.

3. Long-running tasks (e.g., I/O) are offloaded to the worker threads, and their results are
pushed back to the event loop when ready.

15. What is the fs module used for?

7/105
The fs (File System) module in Node.js provides methods to interact with the file system,
such as reading, writing, deleting, and updating files or directories.

Common Methods:

fs.readFile : Asynchronously reads a file.

fs.writeFile : Asynchronously writes data to a file.

fs.rename : Renames a file or directory.

fs.unlink : Deletes a file.

Example:

javascript

const fs = require('fs');
fs.readFile('example.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log(data);
});

16. How can you read a file synchronously in Node.js?

You can use fs.readFileSync to read a file synchronously.

Example:

javascript

const fs = require('fs');
const data = fs.readFileSync('example.txt', 'utf8');
console.log(data);

This method blocks the execution of subsequent code until the file is fully read.

17. How do you handle errors in Node.js?

8/105
Error handling in Node.js can be done using:

1. Callbacks: Pass an error object as the first argument to the callback.

2. Try-Catch: For synchronous operations or Promise-based functions.

3. Event Emitters: Listen for error events.

4. Global Handlers: Use process.on('uncaughtException') to catch unhandled

exceptions (not recommended for all use cases).

Example (Callback):

javascript

const fs = require('fs');
fs.readFile('example.txt', 'utf8', (err, data) => {
if (err) {
console.error('Error reading file:', err.message);
} else {
console.log(data);
}
});

18. What is npm, and why is it important?

npm (Node Package Manager) is the default package manager for Node.js. It helps
developers manage dependencies and share reusable code.

Why it’s important:

Provides access to a vast library of open-source packages.

Simplifies dependency management through package.json .

Allows version control and updates for dependencies.

Supports custom scripts for project automation.

19. How do you update a package using npm?

9/105
To update a package:

1. Run:
bash

npm update <package-name>

2. To update globally installed packages:

bash

npm update -g <package-name>

3. To ensure the latest version is installed:

bash

npm install <package-name>@latest

20. What is the difference between setTimeout and setInterval ?

Feature setTimeout setInterval

Purpose Executes a function after a delay. Repeatedly executes a function at

intervals.

Execution Executes once after the specified delay. Executes repeatedly until cleared.

Clearing Use clearTimeout(timerId) . Use clearInterval(intervalId) .

Example

Code ```javascript ```javascript

Example

setTimeout(() => console.log('Hello'), const intervalId = setInterval(() => {

1000);

console.log('Hello');

}, 1000);

``` ```

10/105
21. What is the difference between npm install and npm install --
save ?

Command Purpose Behavior

npm install Installs all dependencies listed in Does not modify package.json ; it simply
package.json . ensures the required packages are installed.

npm install - Installs a specific package and Automatically updates the dependencies
-save adds it to dependencies . section of package.json .

Note: As of npm 5 (released in 2017), --save is the default behavior for npm install .
Explicitly using --save is no longer necessary.

Example:

bash

npm install express # Adds express to dependencies (default behavior)

npm install express --save # Does the same as above (deprecated syntax)

22. How do you uninstall a package in Node.js?

To uninstall a package:

1. Open a terminal and navigate to the project directory.

2. Run:
bash

npm uninstall <package-name>

3. To remove it globally:

bash

npm uninstall -g <package-name>

4. To remove the package from package.json :

bash

11/105
 npm uninstall <package-name> --save

23. What is a callback function in Node.js?

A callback function is a function passed as an argument to another function and is executed
after the completion of an asynchronous operation. This allows non-blocking execution in
Node.js.

Example (Reading a file with a callback):

javascript

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {

if (err) {
console.error('Error:', err);
} else {
console.log('File Content:', data);
}
});

In this example:

fs.readFile is asynchronous.

The callback function ( (err, data) => {} ) runs when the file is read or if an error
occurs.

24. How do you handle multiple requests in a Node.js server?

Node.js handles multiple requests using its event-driven, non-blocking I/O model. The
server processes incoming requests through a single-threaded event loop, delegating I/O
operations to worker threads when necessary.

Example:

12/105
 javascript

const http = require('http');

const server = http.createServer((req, res) => {

if (req.url === '/') {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Welcome to the homepage!');
} else if (req.url === '/about') {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('About page');
} else {
res.writeHead(404, { 'Content-Type': 'text/plain' });
res.end('Page not found');
}
});

server.listen(3000, () => {
console.log('Server running at http://localhost:3000');
});

Requests are queued, and their responses are handled asynchronously.

I/O-heavy operations (e.g., database calls) are offloaded to the event loop or worker
threads.

25. What is the purpose of the console module in Node.js?

The console module provides a simple debugging and logging utility. It is similar to the
console object in the browser and is used to output messages to the terminal or
stdout/stderr streams.

Common Methods:

console.log : Outputs to the standard output (stdout).

console.error : Outputs to the standard error (stderr).

console.warn : Outputs warnings (stderr).

console.table : Displays tabular data.

13/105
 console.time and console.timeEnd : Measures execution time for code.

Example:

javascript

console.log('This is a log message');

console.error('This is an error message');
console.table([{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]);
console.time('Execution Time');
setTimeout(() => {
console.timeEnd('Execution Time');
}, 1000);

This module is especially helpful during development for debugging purposes.

26. What is the difference between CommonJS and ES6 modules?

Feature CommonJS ES6 Modules

Syntax Uses require to import and Uses import and export keywords.
module.exports to export.

Default Support Default module system in Node.js Supported in modern Node.js (v12+ with
before v13. flag, v13+ without flag).

File Extension Files typically use .js . Files must use .mjs (or set type:
"module" in package.json ).

Execution Synchronous, as require is Asynchronous, allowing parallel loading.

Model blocking.

Interoperability Can import ES6 modules with Can use require with createRequire
dynamic import . function.

Example:

CommonJS:

javascript

// math.js
module.exports.add = (a, b) => a + b;

// app.js
const math = require('./math');
console.log(math.add(2, 3)); // 5

14/105
 ES6 Modules:

javascript

// math.mjs
export const add = (a, b) => a + b;

// app.mjs
import { add } from './math.mjs';
console.log(add(2, 3)); // 5

27. How do you manage environment variables in a Node.js

application?
Environment variables are used to configure applications dynamically without hardcoding
sensitive or environment-specific information. They can be accessed through the
process.env object in Node.js.

Steps to Manage Environment Variables:

1. Define Variables: Create a .env file in your project root.

makefile

DB_HOST=localhost
DB_USER=root
DB_PASS=securepassword

2. Load Variables: Use the dotenv package to load these into process.env .

bash

npm install dotenv

3. Access Variables in Code:

javascript

require('dotenv').config();

15/105
 console.log(process.env.DB_HOST); // Outputs: localhost
console.log(process.env.DB_USER); // Outputs: root

4. Best Practices:

Do not commit .env to version control.

Use process.env for accessing variables safely.

28. Explain streams in Node.js.

Streams in Node.js are objects that handle continuous data flows, enabling efficient I/O
operations by processing data chunk-by-chunk, rather than loading it all into memory.

Types of Streams:

1. Readable Streams: For reading data (e.g., fs.createReadStream ).

2. Writable Streams: For writing data (e.g., fs.createWriteStream ).

3. Duplex Streams: Both readable and writable (e.g., TCP sockets).

4. Transform Streams: Duplex streams that modify data (e.g., zlib for compression).

Key Events:

data : Emitted when data is available.

end : Emitted when no more data is available.

error : Emitted if an error occurs.

Example:

javascript

const fs = require('fs');

// Create a readable stream

const readable = fs.createReadStream('input.txt', 'utf8');

// Handle stream events

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

16/105
 readable.on('end', () => {
console.log('Stream ended.');
});

29. What is middleware in the context of Node.js?

Middleware in Node.js refers to functions that execute during the lifecycle of a request to a
server. They are used to process requests, handle authentication, perform logging, or modify
responses before they reach the client.

Key Characteristics:

Middleware functions take three arguments: (req, res, next) .

The next function passes control to the next middleware.

Middleware is executed in sequence.

Example Without Express.js:

javascript

const http = require('http');

// Middleware function
function logger(req, res, next) {
console.log(`${req.method} ${req.url}`);
next();
}

// Simple middleware handler

function middleware(req, res) {
logger(req, res, () => {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Hello, world!');
});
}

const server = http.createServer(middleware);

server.listen(3000, () => {

17/105
 console.log('Server running on http://localhost:3000');
});

30. How do you use the crypto module to hash data in Node.js?
The crypto module in Node.js provides cryptographic functionality, including creating
hashes, which are fixed-size strings generated from input data. Hashes are commonly used
for checksums and password storage.

Steps to Hash Data:

1. Import the crypto module.

2. Use the crypto.createHash method with an algorithm like sha256 , md5 , etc.

3. Update the hash object with data and output the result.

Example:

javascript

const crypto = require('crypto');

// Hashing data using SHA-256

const data = 'Hello, world!';
const hash = crypto.createHash('sha256').update(data).digest('hex');

console.log('Hash:', hash);
// Example output: "Hash:
a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b92dbb8a62d93d799"

Notes:

Use strong algorithms like sha256 or sha512 for security.

Avoid md5 or sha1 for sensitive data as they are considered weak.

31. Explain the concept of asynchronous programming in Node.js.

Asynchronous programming allows Node.js to perform non-blocking operations, enabling
efficient execution of I/O tasks. Instead of waiting for a task (e.g., file reading or network

18/105
request) to complete, Node.js moves on to execute other tasks, enhancing performance and
scalability.

Key Features:

Non-Blocking I/O: Tasks like file operations or database queries are handled in the
background, freeing the event loop for other operations.

Callback Functions: Functions that execute once an asynchronous task completes.

Promises & async/await : Modern syntax for managing asynchronous flows more
readably.

Event Loop: Central mechanism managing callbacks and deferring long-running

operations to worker threads.

Example:

javascript

const fs = require('fs');

// Asynchronous File Read

fs.readFile('example.txt', 'utf8', (err, data) => {
if (err) {
console.error('Error:', err);
} else {
console.log('File content:', data);
}
});

console.log('This executes before file reading finishes.');

32. What are the different types of streams in Node.js?

Node.js streams provide a way to handle continuous data efficiently. There are four main
types of streams:

1. Readable Streams: For reading data (e.g., file reading, HTTP request body).

Example: fs.createReadStream()

19/105
 Events: data , end , error

2. Writable Streams: For writing data (e.g., file writing, HTTP response).

Example: fs.createWriteStream()

Methods: .write() , .end()

3. Duplex Streams: For both reading and writing (e.g., sockets).

Example: net.Socket

Readable and writable interfaces.

4. Transform Streams: A type of Duplex stream that modifies data as it passes through
(e.g., compression, encryption).

Example: zlib.createGzip()

Example (Readable + Writable):

javascript

const fs = require('fs');

const readable = fs.createReadStream('input.txt');

const writable = fs.createWriteStream('output.txt');

readable.pipe(writable);
console.log('Data is being copied from input.txt to output.txt.');

33. How does Node.js handle child processes?

Node.js provides the child_process module to spawn child processes, enabling tasks to run
concurrently. This is useful for performing CPU-intensive operations without blocking the
main event loop.

Methods to Create Child Processes:

1. spawn : Launches a new process for streaming data.

javascript

20/105
 const { spawn } = require('child_process');
const ls = spawn('ls', ['-lh', '/usr']);

ls.stdout.on('data', (data) => {

console.log(`Output: ${data}`);
});

ls.on('close', (code) => {

console.log(`Child process exited with code ${code}`);
});

2. exec : Executes a command and buffers the output.

javascript

const { exec } = require('child_process');

exec('ls -lh', (err, stdout, stderr) => {
if (err) throw err;
console.log(`Output: ${stdout}`);
});

3. fork : Specifically for running another Node.js script.

javascript

const { fork } = require('child_process');

const child = fork('child_script.js');

child.on('message', (msg) => {

console.log('Message from child:', msg);
});

child.send({ hello: 'world' });

34. How do you handle file uploads in a Node.js application?

File uploads are handled in Node.js using the http module or third-party libraries like
formidable or multer . Below is an example using the http module without any external

21/105
libraries.

Steps:

1. Parse the incoming request for multipart data.

2. Write the uploaded file's data to the server.

Example:

javascript

const http = require('http');

const fs = require('fs');

http.createServer((req, res) => {

if (req.method === 'POST') {
const file = fs.createWriteStream('uploaded_file.txt');
req.pipe(file);

req.on('end', () => {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('File uploaded successfully.');
});
} else {
res.writeHead(200, { 'Content-Type': 'text/html' });
res.end(`
<form method="POST" enctype="multipart/form-data">
<input type="file" name="file" />
<button type="submit">Upload</button>
</form>
`);
}
}).listen(3000, () => {
console.log('Server listening on http://localhost:3000');
});

35. What is Cluster in Node.js, and how does it work?

22/105
The cluster module in Node.js enables the creation of multiple processes (workers) to
utilize multiple CPU cores effectively. Each worker runs an instance of the application,
sharing the same server port.

How It Works:

1. The master process spawns worker processes.

2. Each worker handles incoming requests independently.

3. The master manages worker processes and restarts them if they fail.

Use Case: Clusters are ideal for improving performance in CPU-bound tasks.

Example:

javascript

const cluster = require('cluster');

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

if (cluster.isMaster) {
const numCPUs = os.cpus().length;

console.log(`Master process is running with PID ${process.pid}`);

// Fork workers
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}

cluster.on('exit', (worker, code, signal) => {

console.log(`Worker ${worker.process.pid} exited. Restarting...`);
cluster.fork();
});
} else {
http.createServer((req, res) => {
res.writeHead(200);
res.end(`Hello from Worker ${process.pid}`);
}).listen(3000);

console.log(`Worker process started with PID ${process.pid}`);

}

23/105
Key Notes:

The os.cpus().length method determines the number of CPUs.

Workers share the same server port for load balancing.

Suitable for CPU-intensive applications.

36. Explain how to use the http and https modules in Node.js.
The http and https modules allow Node.js to create HTTP and HTTPS servers and make
HTTP(S) requests.

Creating an HTTP Server:

The http module is used to create a server that listens for requests on a specified port.

Example:

javascript

const http = require('http');

const server = http.createServer((req, res) => {

res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Hello, world!');
});

server.listen(3000, () => {
console.log('HTTP server running at http://localhost:3000');
});

Creating an HTTPS Server:

The https module is used to create secure servers. It requires an SSL certificate and private
key.

Example:

javascript

const https = require('https');

const fs = require('fs');

// Load SSL credentials

const options = {
key: fs.readFileSync('private-key.pem'),

24/105
 cert: fs.readFileSync('certificate.pem'),
};

https.createServer(options, (req, res) => {

res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Secure Hello, world!');
}).listen(3443, () => {
console.log('HTTPS server running at https://localhost:3443');
});

Making HTTP/HTTPS Requests:

Both modules can also make outgoing requests.

Example:

javascript

const https = require('https');

https.get('https://jsonplaceholder.typicode.com/todos/1', (res) => {

let data = '';

res.on('data', chunk => {

data += chunk;
});

res.on('end', () => {
console.log('Response:', data);
});
}).on('error', (err) => {
console.error('Error:', err.message);
});

37. How do you implement authentication in a Node.js application?

Authentication in Node.js can be implemented in various ways depending on the security
requirements. Common approaches include basic authentication, token-based
authentication (e.g., JWT), or OAuth.

25/105
Steps for Token-Based Authentication:

1. Generate a Token:

Use libraries like jsonwebtoken to create a secure token after verifying user
credentials.

bash

npm install jsonwebtoken

javascript

const jwt = require('jsonwebtoken');

const secretKey = 'mySecretKey';

const token = jwt.sign({ userId: 123 }, secretKey, { expiresIn: '1h' });

console.log('JWT Token:', token);

2. Verify Token:

Protect routes by verifying the token during requests.

javascript

const verifyToken = (req, res, next) => {

const token = req.headers['authorization'];
if (!token) return res.status(403).send('No token provided.');

jwt.verify(token, secretKey, (err, decoded) => {

if (err) return res.status(401).send('Invalid token.');
req.userId = decoded.userId;
next();
});
};

3. Apply to Protected Routes:

javascript

const http = require('http');

const server = http.createServer((req, res) => {
if (req.url === '/protected' && req.method === 'GET') {
verifyToken(req, res, () => {

26/105
 res.end('Protected content accessed.');
});
} else {
res.end('Public content.');
}
});

server.listen(3000);

38. What is the EventEmitter class in Node.js?

The EventEmitter class is part of Node.js's events module and allows objects to emit and
listen for events. It is fundamental to Node.js's event-driven architecture.

Basic Usage:

1. Create an EventEmitter Instance:

javascript

const EventEmitter = require('events');

const myEmitter = new EventEmitter();

myEmitter.on('event', () => {
console.log('An event occurred!');
});

myEmitter.emit('event'); // Outputs: An event occurred!

2. Handling Events with Arguments:

javascript

myEmitter.on('greet', (name) => {

console.log(`Hello, ${name}!`);
});

myEmitter.emit('greet', 'Alice'); // Outputs: Hello, Alice!

3. Predefined Events: EventEmitter also emits system events like error .

27/105
 javascript

myEmitter.on('error', (err) => {

console.error('Error occurred:', err.message);
});

myEmitter.emit('error', new Error('Something went wrong'));

39. How do you handle uncaught exceptions in Node.js?

Uncaught exceptions in Node.js can crash the application. To handle these, you can use the
process.on('uncaughtException') event. However, this should be a last resort.

Example:

javascript

process.on('uncaughtException', (err) => {

console.error('Uncaught Exception:', err.message);
// Optionally clean up resources before exiting
process.exit(1);
});

// Intentionally causing an exception

throw new Error('This is an uncaught exception.');

Best Practices:

1. Use proper error handling ( try-catch or .catch() for Promises).

2. Log uncaught exceptions for debugging.

3. Consider process restarts using tools like PM2.

40. Explain the readable and writable streams in Node.js.

Streams are data-handling objects in Node.js. Readable and Writable streams process data
incrementally rather than loading it all into memory.

28/105
Readable Streams:

These are used to read data in chunks.

Example (Reading a File):

javascript

const fs = require('fs');

const readable = fs.createReadStream('example.txt', 'utf8');

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

readable.on('end', () => {
console.log('No more data.');
});

Writable Streams:

These are used to write data in chunks.

Example (Writing to a File):

javascript

const fs = require('fs');

const writable = fs.createWriteStream('output.txt');

writable.write('Hello, world!\n');
writable.write('Appending some data.');
writable.end(() => {
console.log('Finished writing to file.');
});

Piping (Connecting Readable to Writable):

Streams can be chained together using .pipe() .

Example:

javascript

const readable = fs.createReadStream('example.txt');

const writable = fs.createWriteStream('copy.txt');

29/105
 readable.pipe(writable);
console.log('File copied successfully.');

41. What are the benefits of using the express framework?

Express is a lightweight and flexible web application framework for Node.js, designed to

simplify the process of building robust web applications and APIs. Its benefits include:

1. Simplified Routing:

Easy to define and manage routes for HTTP requests.

javascript

const express = require('express');

const app = express();

app.get('/', (req, res) => {

res.send('Hello, World!');
});

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

2. Middleware Support:

Provides a robust middleware system to process requests (e.g., for authentication,

logging, etc.).

3. Extensibility:

Compatible with many plugins for extended functionality (e.g., body parsing, cookies).

4. Scalability:

Ideal for building RESTful APIs and scalable web applications.

5. Community Support:

Extensive documentation and a large community offer reliable solutions for common
challenges.

30/105
42. How do you create a RESTful API in Node.js?
To create a RESTful API, follow these steps:

Step 1: Set Up Node.js and Express

Install Express:

bash

npm install express

Step 2: Define Routes

Create routes for CRUD operations ( GET , POST , PUT , DELETE ).

Example:

javascript

const express = require('express');

const app = express();

// Middleware to parse JSON

app.use(express.json());

let items = [
{ id: 1, name: 'Item 1' },
{ id: 2, name: 'Item 2' },
];

// GET: Fetch all items

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

// POST: Add a new item

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

// PUT: Update an item

app.put('/items/:id', (req, res) => {

31/105
 const item = items.find(i => i.id == req.params.id);
if (item) {
item.name = req.body.name;
res.json(item);
} else {
res.status(404).send('Item not found');
}
});

// DELETE: Remove an item

app.delete('/items/:id', (req, res) => {
items = items.filter(i => i.id != req.params.id);
res.status(204).send();
});

// Start server
app.listen(3000, () => console.log('API running on port 3000'));

43. What is the purpose of the child_process module?

The child_process module in Node.js is used to spawn and manage subprocesses, allowing
you to execute system commands or other scripts from your Node.js application. It is useful
for:

Key Use Cases:

1. Executing Shell Commands:

Use exec to execute commands and capture their output.

javascript

const { exec } = require('child_process');

exec('ls', (err, stdout, stderr) => {
if (err) throw err;
console.log('Output:', stdout);
});

2. Streaming Data:

32/105
 Use spawn to handle large data streams between parent and child processes.

javascript

const { spawn } = require('child_process');

const ls = spawn('ls', ['-lh']);

ls.stdout.on('data', (data) => console.log(`Output: ${data}`));

3. Running Node.js Scripts:

Use fork to create child processes specifically for Node.js scripts.

javascript

const { fork } = require('child_process');

const child = fork('child.js');

44. How do you use promises in Node.js?

Promises provide a way to handle asynchronous operations, improving readability and
avoiding callback hell.

Creating a Promise:

javascript

const myPromise = new Promise((resolve, reject) => {

const success = true;
if (success) {
resolve('Operation succeeded');
} else {
reject('Operation failed');
}
});

Using Promises with .then() and .catch() :

javascript

33/105
 myPromise
.then(result => console.log(result)) // Output: Operation succeeded
.catch(error => console.error(error));

Using async/await :

async/await simplifies promise usage by making asynchronous code look synchronous.

javascript

const asyncFunction = async () => {

try {
const result = await myPromise;
console.log(result);
} catch (error) {
console.error(error);
}
};

asyncFunction();

Example (Using Promises for File Reading):

javascript

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));

45. How do you implement WebSockets in Node.js?

WebSockets provide a persistent, full-duplex communication channel between the server
and the client. In Node.js, you can implement WebSockets using the built-in ws library.

Steps to Implement WebSockets:

1. Install ws :

34/105
 bash

npm install ws

2. Create a WebSocket Server:

javascript

const WebSocket = require('ws');

const server = new WebSocket.Server({ port: 8080 });

server.on('connection', (socket) => {

console.log('Client connected');

// Listen for messages

socket.on('message', (message) => {
console.log('Received:', message);
socket.send(`Echo: ${message}`);
});

// Handle disconnection
socket.on('close', () => {
console.log('Client disconnected');
});
});

console.log('WebSocket server running on ws://localhost:8080');

3. Client Implementation:

javascript

const socket = new WebSocket('ws://localhost:8080');

socket.onopen = () => {
console.log('Connected to server');
socket.send('Hello, server!');
};

socket.onmessage = (event) => {

console.log('Received from server:', event.data);
};

35/105
 socket.onclose = () => console.log('Disconnected from server');

Summary:
Express Framework: Simplifies building web apps and APIs.

RESTful API: Use Express with HTTP verbs ( GET , POST , etc.) to manage resources.

child_process Module: Execute external commands or scripts.

Promises: Handle asynchronous tasks cleanly with .then , .catch , or async/await .

WebSockets: Enable real-time, bidirectional communication using the ws library.

46. Explain the role of the zlib module in Node.js.

The zlib module in Node.js is used for compression and decompression of data. It
provides bindings to the popular zlib compression library in C, allowing developers to
efficiently compress and decompress data in formats like Gzip and Deflate.

Use Cases:

Compressing HTTP responses to reduce bandwidth usage.

Archiving files with compressed formats.

Handling compressed streams of data.

Example (Compressing and Decompressing):

1. Compressing a File:

javascript

const zlib = require('zlib');

const fs = require('fs');

const input = fs.createReadStream('example.txt');

const output = fs.createWriteStream('example.txt.gz');

input.pipe(zlib.createGzip()).pipe(output);
console.log('File compressed successfully.');

36/105
2. Decompressing a File:

javascript

const input = fs.createReadStream('example.txt.gz');

const output = fs.createWriteStream('decompressed.txt');

input.pipe(zlib.createGunzip()).pipe(output);
console.log('File decompressed successfully.');

47. How do you debug a Node.js application?

Debugging is an essential step in the development process. Node.js provides several tools
for debugging.

1. Using the --inspect Flag:

Run the application with the --inspect flag to enable debugging.

bash

node --inspect app.js

Open Chrome DevTools and connect to the debugging URL printed in the terminal.

2. Using console.log :

Insert console.log statements to print variable values and track execution flow.

3. Using debugger Statement:

Insert the debugger keyword in your code where you want to pause execution.

javascript

let x = 10;
debugger; // Execution stops here
x += 20;
console.log(x);

37/105
4. Using a Debugger Tool (e.g., VS Code):

Set breakpoints and step through the code using an IDE like Visual Studio Code.

Open the Run and Debug panel.

Add a breakpoint and start debugging.

5. Using Third-Party Tools:

Tools like ndb offer enhanced debugging capabilities.

bash

npm install -g ndb

ndb app.js

48. What is the purpose of the os module in Node.js?

The os module provides utilities to interact with the operating system. It helps retrieve
system information, such as CPU details, memory usage, and network interfaces.

Key Methods:

1. Getting System Info:

Retrieve platform, architecture, and uptime.

javascript

const os = require('os');
console.log('Platform:', os.platform());
console.log('Architecture:', os.arch());
console.log('Uptime (seconds):', os.uptime());

2. Getting CPU Details:

javascript

console.log('CPU Info:', os.cpus());

3. Memory Usage:

38/105
 Retrieve total and free memory.

javascript

console.log('Total Memory:', os.totalmem());

console.log('Free Memory:', os.freemem());

4. Network Interfaces:

javascript

console.log('Network Interfaces:', os.networkInterfaces());

5. Home Directory:

javascript

console.log('Home Directory:', os.homedir());

49. How do you use async/await in Node.js?

async/await is a syntactic feature in JavaScript for handling asynchronous code in a cleaner,
more readable way. It works with promises and is ideal for avoiding callback hell.

Using async and await :

1. Declare a function as async .

2. Use await to pause execution until a promise resolves.

Example:

javascript

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

async function readFileContent() {

try {
const data = await fs.readFile('example.txt', 'utf8');
console.log('File content:', data);
} catch (err) {

39/105
 console.error('Error reading file:', err);
}
}

readFileContent();

Handling Multiple Promises:

Use Promise.all with async/await to handle multiple asynchronous operations.

javascript

async function getData() {

const [file1, file2] = await Promise.all([
fs.readFile('file1.txt', 'utf8'),
fs.readFile('file2.txt', 'utf8'),
]);
console.log('File1:', file1);
console.log('File2:', file2);
}
getData();

50. How do you schedule tasks in Node.js?

Node.js allows you to schedule tasks to run at specified intervals or after a delay. This is
typically done using built-in functions like setTimeout , setInterval , or third-party libraries
like node-schedule .

1. Using setTimeout :

Executes a function after a specified delay.

javascript

setTimeout(() => {
console.log('Task executed after 2 seconds');
}, 2000);

2. Using setInterval :

40/105
Executes a function repeatedly at a fixed interval.

javascript

setInterval(() => {
console.log('Task executed every 3 seconds');
}, 3000);

3. Using clearTimeout and clearInterval :

Cancel scheduled tasks.

javascript

const timer = setTimeout(() => {

console.log('This will not run');
}, 5000);

clearTimeout(timer);

4. Using node-schedule (Third-Party Library):

To schedule more complex tasks (e.g., Cron jobs):

bash

npm install node-schedule

javascript

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

schedule.scheduleJob('*/5 * * * * *', () => {

console.log('Task executed every 5 seconds');
});

Summary:
zlib : Handles compression and decompression (e.g., Gzip).

41/105
 Debugging: Use --inspect , debugger , or IDE tools like VS Code.

os Module: Provides system-level information (e.g., CPU, memory).

Async/Await: Simplifies promise-based asynchronous operations.

Task Scheduling: Use setTimeout , setInterval , or libraries like node-schedule for

Cron-like tasks.

51. What is the difference between process.nextTick and

setImmediate ?

Both process.nextTick and setImmediate are used to schedule callbacks in Node.js, but
they differ in their execution timing within the event loop.

process.nextTick :

Executes callbacks before the next iteration of the event loop begins.

It's a part of the microtask queue and has higher priority than the timers phase.

Suitable for deferring tasks to execute as soon as the current operation is complete.

setImmediate :

Executes callbacks in the check phase of the event loop, after I/O events.

It's part of the macrotask queue and will run after microtasks are completed.

Example:

javascript

console.log('Start');

process.nextTick(() => console.log('NextTick'));

setImmediate(() => console.log('SetImmediate'));

console.log('End');

Output:

sql

Start
End

42/105
 NextTick
SetImmediate

Key Difference:

process.nextTick : Runs before setImmediate as it has a higher priority.

Use Case for process.nextTick : Critical operations to execute immediately after the
current function.

Use Case for setImmediate : Tasks to run after I/O events.

52. Explain the concept of backpressure in Node.js streams.

Backpressure occurs in Node.js streams when the rate of data production (write stream)
exceeds the rate of data consumption (read stream). This imbalance can cause memory
overflow if not properly managed.

How Backpressure Happens:

1. The producer generates data faster than the consumer can process it.

2. The writable buffer fills up, and the writable stream signals the producer to stop sending
more data.

Managing Backpressure:

Use the write() method's return value:

javascript

const writable = fs.createWriteStream('output.txt');

let canWrite = writable.write('Some data');

if (!canWrite) {
writable.once('drain', () => {
console.log('Drain event fired, resuming writes.');
writable.write('More data');
});
}

Use pipe for automatic backpressure handling:

43/105
 javascript

const readable = fs.createReadStream('input.txt');

const writable = fs.createWriteStream('output.txt');

readable.pipe(writable); // Automatically manages backpressure

Why It Matters:

Properly handling backpressure ensures efficient resource usage and prevents system
crashes due to memory overload.

53. How do you optimize the performance of a Node.js application?

Optimizing a Node.js application involves improving its speed, scalability, and efficiency. Here
are key strategies:

1. Optimize I/O Operations:

Use asynchronous I/O methods.

Implement streams for handling large datasets.

2. Efficient Memory Management:

Avoid memory leaks by tracking object references.

Use tools like clinic or node-inspect for profiling.

3. Use Clustering:

Distribute workload across multiple CPU cores using the cluster module.

javascript

const cluster = require('cluster');

const http = require('http');

if (cluster.isMaster) {
const numCPUs = require('os').cpus().length;
for (let i = 0; i < numCPUs; i++) cluster.fork();
} else {

44/105
 http.createServer((req, res) => {
res.end('Hello World');
}).listen(3000);
}

4. Use Caching:

Implement caching for repeated requests (e.g., in-memory caching with Redis ).

5. Reduce Middleware Overhead:

Only use necessary middleware and keep middleware chains short.

6. Enable Gzip Compression:

Use the zlib module for compressing responses to reduce bandwidth usage.

7. Optimize Database Queries:

Use efficient queries and indexes.

Batch database operations to minimize connections.

8. Monitor and Profile:

Use monitoring tools like PM2, New Relic, or AppDynamics.

54. What are worker threads in Node.js, and how are they used?
Worker threads in Node.js provide a way to execute JavaScript code in parallel, leveraging
multiple threads in a single Node.js process. This is useful for CPU-intensive tasks.

Why Use Worker Threads?

Node.js is single-threaded for JavaScript execution. Worker threads allow offloading heavy
tasks, preventing them from blocking the main thread.

How to Use Worker Threads:

1. Import the Worker class from the worker_threads module.

2. Create a worker and specify the script or code to execute.

Example:

45/105
 javascript

const { Worker, isMainThread, parentPort } = require('worker_threads');

if (isMainThread) {
const worker = new Worker( filename);

worker.on('message', (message) => console.log('From Worker:', message));

worker.postMessage('Hello Worker');
} else {
parentPort.on('message', (message) => {
parentPort.postMessage(`Received: ${message}`);
});
}

Use Cases:

Processing large datasets.

Performing cryptographic operations.

Image or video processing.

55. How does Node.js manage memory?

Node.js uses V8's garbage collector for memory management. Memory is divided into
different regions for optimized allocation and deallocation.

Memory Structure:

1. Stack:

Stores function calls and local variables.

Limited in size.

2. Heap:

Stores objects, closures, and global variables.

Where garbage collection occurs.

3. C++ Objects:

Native objects managed outside of the V8 heap.

46/105
Garbage Collection:

Garbage collection in Node.js is automatic but can cause performance issues during large
sweeps.

Mark-and-Sweep Algorithm:

Marks unused objects in memory and clears them.

Incremental GC:

Breaks large sweeps into smaller tasks for better performance.

Memory Management Tips:

1. Avoid Memory Leaks:

Keep track of references to prevent objects from lingering in memory.

Use tools like heapdump to analyze memory usage.

2. Use Streams:

Avoid loading large files or data sets into memory; use streams to process data in
chunks.

3. Limit Memory Usage:

Configure memory limits using the --max-old-space-size flag.

bash

node --max-old-space-size=4096 app.js

4. Monitoring:

Use process.memoryUsage() to monitor memory consumption:

javascript

console.log(process.memoryUsage());

Summary:
process.nextTick vs. setImmediate : Microtask vs. macrotask execution.

47/105
 Backpressure: Prevents memory overflow in streams by pausing data flow.

Performance Optimization: Involves efficient I/O, clustering, caching, and database

tuning.

Worker Threads: Enable parallel execution of CPU-bound tasks.

Memory Management: Uses V8's garbage collector; monitor and optimize usage to
prevent leaks.

56. What are the main differences between Node.js and other server-
side technologies like PHP?
Node.js and PHP are both popular server-side technologies, but they differ in several
fundamental aspects.

1. Language and Runtime:

Node.js:

Node.js is a runtime environment for executing JavaScript on the server-side. It is

built on Google's V8 JavaScript engine and allows developers to use JavaScript for
both frontend and backend development.

Event-driven and Non-blocking: Node.js uses an asynchronous, event-driven

architecture, which makes it efficient for I/O-bound tasks.

PHP:

PHP is a scripting language primarily designed for web development. It is

traditionally embedded in HTML to produce dynamic web pages.

Synchronous: PHP processes requests synchronously, meaning each request is

handled one at a time.

2. Performance:

Node.js: Due to its non-blocking, event-driven architecture, Node.js is well-suited for

handling a large number of concurrent requests (e.g., for real-time applications or APIs).

PHP: PHP is generally better suited for typical server-rendered web applications but can
struggle with highly concurrent or real-time applications due to its synchronous
processing.

3. Concurrency Model:

48/105
 Node.js: Uses a single-threaded event loop and non-blocking I/O to handle multiple
requests simultaneously without the need for multiple threads. It scales well with tasks
that are I/O-bound but not CPU-intensive.

PHP: Each incoming request is handled by a new process or thread. It is often paired
with web servers like Apache or Nginx, which spawn multiple worker processes to
handle requests.

4. Ecosystem and Package Management:

Node.js: Uses npm (Node Package Manager), which has a large ecosystem of libraries
and modules for all sorts of tasks (from web frameworks to data manipulation).

PHP: Uses Composer for managing dependencies, and while its ecosystem is strong, it’s
not as modern or as large as Node.js's npm.

5. Learning Curve:

Node.js: Developers familiar with JavaScript can transition to server-side development

easily, but understanding asynchronous programming (callbacks, promises, async/await)
is crucial.

PHP: PHP has a relatively low learning curve and is designed specifically for web
development, making it easy for beginners to get started with server-side development.

57. How do you handle circular dependencies in Node.js modules?

Circular dependencies occur when two or more modules depend on each other directly or
indirectly. In Node.js, circular dependencies can lead to unexpected behavior, such as
incomplete module loading.

How Node.js Handles Circular Dependencies:

1. When a module is required, Node.js loads it and caches the result.

2. If a module has already been loaded, Node.js returns the cached version, even if it is still
in the process of loading.

3. As a result, if a circular dependency exists, the first module will receive an incomplete
version of the second module until the module has finished loading.

Handling Circular Dependencies:

49/105
 Refactor the Code: Break the circular dependency by restructuring the code. Move
shared functionality into a separate module or separate concerns to avoid
interdependence.

Lazy Loading: Delay the require statement until it's absolutely necessary. This can
sometimes prevent circular dependency issues by ensuring the modules are only loaded
when they are needed.

javascript

// Instead of requiring the module at the top, require it when needed

function foo() {
const bar = require('./bar');
bar.doSomething();
}

Use exports Carefully: Be cautious about modifying exports after the module has
been loaded, as it can result in partial exports being used.

58. What is the purpose of the v8 module in Node.js?

The v8 module provides bindings to the V8 JavaScript engine used by Node.js. This module
allows developers to interact directly with the engine to optimize and debug performance.

Key Features of the v8 Module:

Heap Snapshot: Allows taking a snapshot of the heap for memory usage analysis.

Garbage Collection: Provides methods for controlling or observing garbage collection.

Memory Allocation: Helps inspect and manage memory allocated to the V8 heap.

Customizable Flags: Allows for setting custom V8 flags to influence the behavior of the
engine (e.g., to enable or disable specific optimizations).

Example Usage:

You can use the v8 module to access heap statistics or take heap snapshots for debugging:

javascript

50/105
 const v8 = require('v8');
console.log(v8.getHeapStatistics());

59. Explain how the cluster module can be used for scaling applications.
The cluster module in Node.js allows you to create child processes (workers) that can
share the same server port. It is useful for scaling applications to take advantage of multi-
core systems.

How It Works:

Node.js is single-threaded, which means it can only use one CPU core. The cluster
module allows you to fork multiple processes to use multiple cores, enabling you to
handle more traffic efficiently.

Each worker is an independent process, but they share the same server socket, making it
easier to scale the application horizontally.

Basic Example:

javascript

const cluster = require('cluster');

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

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

cluster.on('exit', (worker, code, signal) => {

console.log(`Worker ${worker.process.pid} died`);
});
} else {
// Worker processes handle requests
http.createServer((req, res) => {

51/105
 res.writeHead(200);
res.end('Hello from Node.js cluster!');
}).listen(8000);
}

Benefits of Clustering:

Increased Concurrency: Each worker can handle multiple requests concurrently.

Fault Tolerance: If one worker crashes, other workers can continue to handle requests.

Optimal CPU Utilization: Clustering allows Node.js to make use of all available CPU
cores.

60. What is the difference between a process and a thread in Node.js?

In Node.js, understanding the difference between a process and a thread is essential,
especially when dealing with concurrent programming.

1. Process:

A process is an independent execution unit that has its own memory space, system
resources, and execution context.

Each Node.js application runs as a single process.

Processes are isolated from each other and cannot directly access each other’s memory.

2. Thread:

A thread is a smaller unit of execution within a process. Threads share the same
memory space and resources as their parent process.

Node.js is single-threaded by default, meaning the event loop and JavaScript execution
happen in a single thread.

However, Node.js can spawn additional threads for certain tasks, such as using the
worker threads module for parallel processing.

Key Differences:

Memory: Processes have their own memory, while threads share memory with other
threads in the same process.

52/105
 Performance: Processes are more isolated, leading to higher overhead, whereas threads
are more lightweight but can lead to concurrency issues if not properly managed.

Concurrency: Node.js uses a single thread for JavaScript execution but employs
additional threads for I/O operations and background tasks (e.g., the worker threads
module).

Summary:
Node.js vs. PHP: Node.js is event-driven, non-blocking, and uses JavaScript, while PHP is
synchronous and uses a different model for processing requests.

Circular Dependencies: Can be handled by refactoring code or using lazy loading.

v8 Module: Provides access to V8 engine features like memory management and

garbage collection.

Cluster Module: Enables multi-core scaling by forking worker processes.

Processes vs. Threads: Processes are independent units of execution with separate
memory, while threads share memory within a process and are lighter weight.

61. How does Node.js handle asynchronous I/O operations?

Node.js uses a non-blocking, event-driven model to handle asynchronous I/O operations.
This allows Node.js to handle many I/O tasks concurrently without waiting for one task to
complete before starting another. Here's how it works:

Key Concepts:

Event Loop: The event loop in Node.js constantly monitors the event queue and
processes I/O operations as they complete. The event loop runs in a single thread, and
when an I/O operation is requested (e.g., reading from a file or making an HTTP
request), Node.js offloads this task to the operating system, freeing up the event loop to
process other tasks.

Callbacks: When an I/O operation is complete, Node.js invokes a callback function that
was registered to handle the result. This callback is added to the event loop’s queue, and
once the current operation finishes, the callback is executed.

Libuv Library: Node.js uses libuv, a multi-platform support library that handles
asynchronous I/O, to manage operations such as file system access, networking, and

53/105
 child process management. It is the foundation behind the non-blocking behavior of
Node.js.

Example:

javascript

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {

if (err) throw err;
console.log(data); // This is called when the file reading is complete
});

console.log("File reading in progress...");

Here, fs.readFile reads a file asynchronously. While the file is being read, Node.js
continues executing the console.log("File reading in progress...") statement.

Advantages:

High concurrency: Non-blocking I/O allows Node.js to handle thousands of concurrent

connections.

Efficiency: Node.js does not wait for I/O operations to finish before continuing with other
tasks, leading to efficient use of system resources.

62. Explain the role of event delegation in Node.js.

Event delegation in Node.js refers to the technique of assigning an event listener to a
parent object rather than multiple individual child objects. This pattern is particularly useful
in scenarios like handling I/O events or when working with streams or large numbers of
event listeners.

While event delegation is commonly discussed in the context of DOM manipulation (e.g., in
browsers), in Node.js, the concept can be applied in several ways:

How it Works:

Instead of attaching event listeners to each individual child object, you attach a listener
to a parent or container object that listens for events that bubble up.

54/105
 When an event is triggered on a child, the parent can delegate the handling of the event
based on the event's properties (like event type or target).

Example in Node.js (HTTP Server):

In a scenario with many routes in an HTTP server, instead of assigning individual listeners for
each route, we can use a single request event listener on the server object:

javascript

const http = require('http');

const server = http.createServer((req, res) => {

if (req.url === '/home') {
res.write('Home Page');
} else if (req.url === '/about') {
res.write('About Page');
}
res.end();
});

server.listen(3000, () => {
console.log('Server is listening on port 3000');
});

Here, event delegation is used by attaching a single listener to the server that handles
different requests, rather than creating individual handlers for each route.

63. How do you ensure thread safety in a Node.js application?

Node.js is single-threaded for JavaScript execution, meaning that only one operation runs at
a time in the event loop. However, issues can arise when working with asynchronous
operations or multiple processes. While thread safety is not an issue in typical Node.js
applications (because of the single-threaded nature of JavaScript execution), it's still
important to consider thread safety when using worker threads, child processes, or external
modules that interact with the system.

How to Ensure Thread Safety:

55/105
 1. Avoid Shared Mutable State: The most important strategy in ensuring thread safety is
to avoid shared mutable state between concurrent tasks. If shared state is needed,
consider using locks or other synchronization techniques.

2. Worker Threads: If you use the worker threads module to run CPU-intensive tasks,
ensure thread safety by passing messages instead of sharing objects directly between
threads.

You can use atomic operations (where possible) to ensure consistency when
multiple threads are involved.

Pass data between threads using postMessage() and handle the result through the
message event.

3. Child Processes: For parallel processing, use child processes in conjunction with the
cluster module. Each child process has its own memory space, avoiding shared state
issues.

4. Libraries: For thread-safe data structures, consider using libraries like async or
immutable.js for managing state in an asynchronous environment.

5. Asynchronous Operations: For asynchronous I/O, Node.js naturally avoids thread safety
issues by not allowing multiple operations to interfere with each other on the main
thread.

Example Using Worker Threads:

javascript

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 Worker');
} else {
parentPort.on('message', (message) => {
parentPort.postMessage(`Received: ${message}`);
});
}

In this example, communication between the main thread and worker thread is done via
messages, ensuring data safety and no shared memory issues.

56/105
64. What is the difference between blocking and non-blocking code in
Node.js?
The distinction between blocking and non-blocking code is crucial in understanding how
Node.js works, especially with respect to asynchronous operations.

Blocking Code:

Blocking refers to operations that stop the execution of subsequent code until the
current operation is finished.

In a blocking operation, Node.js waits for a task to complete before moving on to the
next task, effectively blocking the event loop.

Example of Blocking Code:

javascript

const fs = require('fs');

console.log('Start');
const data = fs.readFileSync('example.txt', 'utf8'); // Blocking
console.log(data);
console.log('End');

In this example, fs.readFileSync is a blocking call. The program waits for the file to be read
before continuing, blocking the event loop and delaying further execution.

Non-blocking Code:

Non-blocking operations allow Node.js to continue executing other code while waiting
for a task to complete. These operations use callbacks, promises, or async/await to
handle the result once the operation finishes.

Example of Non-blocking Code:

javascript

const fs = require('fs');

console.log('Start');
fs.readFile('example.txt', 'utf8', (err, data) => { // Non-blocking

57/105
 if (err) throw err;
console.log(data);
});
console.log('End');

Here, the fs.readFile function is non-blocking. While the file is being read, Node.js
continues to execute the console.log('End') statement, and once the file is read, the
callback is triggered.

Key Difference:

Blocking: Delays the execution of the program until the operation completes.

Non-blocking: Allows other tasks to execute while waiting for the operation to finish.

65. How do you handle large datasets in Node.js efficiently?

Handling large datasets efficiently in Node.js requires strategies that prevent memory
overuse, reduce blocking, and optimize I/O operations. Node.js’s event-driven, non-blocking
nature makes it well-suited for this, but you must still be mindful of performance.

Techniques for Handling Large Datasets:

1. Streams:

Node.js streams allow you to read and write data piece-by-piece, which is
particularly useful for large files or datasets. Instead of loading the entire dataset
into memory, streams read and process data in chunks, helping to conserve
memory.

Readable Streams for input (e.g., reading files or HTTP requests).

Writable Streams for output (e.g., writing to files or sending HTTP responses).

Example:

javascript

const fs = require('fs');
const readableStream = fs.createReadStream('largefile.txt', { encoding: 'utf8'
});

readableStream.on('data', chunk => {

58/105
 console.log(chunk); // Process data chunk by chunk
});

2. Pagination:

When working with large datasets from a database or API, implement pagination to
load and process data in smaller chunks.

Example:

javascript

const pageSize = 100;

let currentPage = 1;

function fetchData(page) {
// Simulate a data fetch
return new Promise(resolve => {
setTimeout(() => resolve(`Data for page ${page}`), 500);
});
}

async function loadData() {

for (let i = 0; i < 1000; i += pageSize) {
const data = await fetchData(currentPage++);
console.log(data); // Process data page by page
}
}
loadData();

3. Batch Processing:

For operations like database writes or API requests, split the large dataset into
smaller batches. This prevents overwhelming the system with too much data at
once and ensures smooth handling.

4. Optimize Memory Usage:

Use buffering techniques when dealing with binary data or large files. Buffers allow
you to work with raw binary data more efficiently than regular strings.

Consider using tools like Redis or MongoDB to store large datasets offload them
from memory.

5. Compression:

59/105
 If you're dealing with large datasets over a network, compressing the data before
sending it can reduce I/O time and memory usage. Node.js has built-in support for
compression via the zlib module.

6. Use External Tools:

When appropriate, consider using external tools or databases like MongoDB,

Cassandra, or Hadoop for processing large datasets, especially if the data is
structured or needs distributed processing.

By using these techniques, Node.js applications can efficiently handle large datasets without
consuming excessive resources or causing performance bottlenecks.

66. Explain how to implement rate-limiting in a Node.js application.

Rate-limiting is used to control the number of requests a user or client can make to an API
or service within a given time period, typically to prevent abuse or overload.

In a Node.js application, you can implement rate-limiting using various approaches,

including third-party libraries like express-rate-limit (if using Express) or by implementing
your own custom solution.

Custom Rate-Limiting Implementation:

1. In-Memory Rate-Limiting:

Track the number of requests from a user (typically using the user's IP address or
session identifier).

Store the timestamps of the user's requests and check if the user has exceeded the
limit within the specified time window.

2. Example:

javascript

const http = require('http');

const rateLimit = new Map(); // Store IP address request count

const requestLimit = 5; // Max requests per time window

const timeWindow = 60 * 1000; // 1 minute

const server = http.createServer((req, res) => {

const ip = req.connection.remoteAddress; // Use IP for identification
const currentTime = Date.now();

60/105
 if (!rateLimit.has(ip)) {
rateLimit.set(ip, []);
}

const requestTimes = rateLimit.get(ip);

// Filter out requests that are older than the time window
rateLimit.set(ip, requestTimes.filter(time => currentTime - time <= timeWindow));

// Check if the request limit has been reached

if (requestTimes.length >= requestLimit) {
res.statusCode = 429; // Too many requests
res.end('Rate limit exceeded. Please try again later.');
} else {
rateLimit.get(ip).push(currentTime); // Record the request
res.statusCode = 200;
res.end('Request accepted');
}
});

server.listen(3000, () => {
console.log('Server is running');
});

This example tracks requests per IP address, and if a user exceeds the limit, it returns a 429
Too Many Requests response.

3. Using Third-Party Libraries:

For more complex rate-limiting needs (e.g., using Redis to persist rate-limit data),
you can use libraries like express-rate-limit .

bash

npm install express-rate-limit

Then, implement it in your application:

javascript

const express = require('express');

const rateLimit = require('express-rate-limit');

61/105
 const app = express();

const limiter = rateLimit({

windowMs: 1 * 60 * 1000, // 1 minute
max: 5, // limit to 5 requests per IP
message: 'Too many requests, please try again later.',
});

app.use(limiter);

app.get('/', (req, res) => {

res.send('Hello World!');
});

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

67. What is a memory leak, and how do you detect it in a Node.js

application?
A memory leak occurs when memory that is no longer needed by the application is not
released, resulting in increased memory usage over time. This can lead to performance
degradation or crashes if the application consumes all available memory.

Detecting Memory Leaks:

1. Use Node.js Profiler:

You can use the built-in --inspect flag in Node.js to start a debugging session and
monitor memory usage.

Example:

bash

node --inspect-brk app.js

62/105
 Then, open Chrome DevTools to monitor memory usage and inspect heap
snapshots.

2. Heap Snapshots:

You can take heap snapshots to analyze memory allocations over time. Tools like
Chrome DevTools or clinic.js can help you visualize memory usage patterns.

3. Using process.memoryUsage() :

The process.memoryUsage() method provides detailed information about the

memory consumption of the Node.js process.

Example:

javascript

setInterval(() => {
console.log(process.memoryUsage());
}, 1000);

4. Third-Party Libraries:

Libraries like memwatch-next or heapdump can help monitor memory usage and
detect leaks by generating memory dumps or alerts when memory usage is
unusually high.

Example with memwatch-next :

bash

npm install memwatch-next

javascript

const memwatch = require('memwatch-next');

memwatch.on('leak', (info) => {

console.log('Memory leak detected:', info);
});

63/105
68. What is the purpose of the domain module, and why is it
deprecated?
The domain module in Node.js was introduced to manage uncaught exceptions in
asynchronous callbacks. It allowed you to group multiple I/O operations and handle errors
for all operations in that group (domain). It provided a mechanism to catch errors that were
otherwise difficult to handle, like those in callbacks.

Purpose:

Error Handling: It was used for catching exceptions in asynchronous code, where the
normal try-catch block would not work.

Grouping Operations: Domains allowed grouping of related I/O operations together to

manage and handle errors more efficiently.

Why is it deprecated?:

The domain module was deprecated in Node.js because its usage often led to
unintended side effects and unpredictable error handling behavior. The asynchronous
model in Node.js (using callbacks, promises, and async/await) makes error handling
more straightforward without requiring special constructs like domains.

Modern JavaScript patterns, such as async/await and global error handlers like
process.on('uncaughtException') , are now preferred for error handling.

Recommendation:

Instead of using domain , handle errors in asynchronous code using try-catch with
async/await or handle event-driven errors with proper error event listeners.

69. How does Node.js handle DNS queries?

Node.js handles DNS (Domain Name System) queries via the dns module, which provides
methods to resolve domain names to IP addresses and vice versa.

Methods in the dns module:

1. dns.lookup() : Resolves a hostname to an IP address.

It uses the operating system's DNS resolver to look up the IP address.

64/105
 Example:
javascript

const dns = require('dns');

dns.lookup('google.com', (err, address, family) => {

if (err) throw err;
console.log('IP address:', address);
});

2. dns.resolve() : Resolves a hostname to a set of records (e.g., A records, MX records).

Example:

javascript

dns.resolve('google.com', 'A', (err, addresses) => {

if (err) throw err;
console.log('A records:', addresses);
});

3. dns.reverse() : Performs a reverse DNS lookup (maps an IP address to a hostname).

Example:

javascript

dns.reverse('8.8.8.8', (err, hostnames) => {

if (err) throw err;
console.log('Reverse lookup:', hostnames);
});

These functions can be used to interact with DNS servers and resolve domains as part of
network operations in Node.js.

70. How do you use the buffer module in Node.js?

The buffer module in Node.js provides a way to handle binary data directly. Buffers are raw
memory allocations, allowing you to work with binary data streams like images, files, or
network packets without the overhead of converting them into strings.

65/105
Creating Buffers:

1. From a String:

javascript

const buffer = Buffer.from('Hello, World!');

console.log(buffer); // Output: <Buffer 48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21>

2. Allocating Buffers:

You can allocate a buffer of a specified size.

javascript

const buffer = Buffer.alloc(10); // Allocates a buffer with 10 bytes

console.log(buffer); // Output: <Buffer 00 00 00 00 00 00 00 00 00 00>

3. From an Array:

javascript

const buffer = Buffer.from([1, 2, 3, 4, 5]);

console.log(buffer); // Output: <Buffer 01 02 03 04 05>

Manipulating Buffers:

You can read and write to buffers using different methods such as .toString() ,
.write() , or .slice() .

Example:

javascript

const buffer = Buffer.from('Hello, Node.js!');

console.log(buffer.toString('utf8', 0, 5)); // Output: Hello

Use Cases:

File Handling: Buffers are used extensively when working with file systems to handle
binary data (e.g., reading/writing images, videos, or other binary files).

Networking: Buffers are useful in network operations where raw binary data needs to
be processed or transferred.

66/105
These are the main concepts related to handling DNS queries and working with the buffer
module in Node.js, along with detailed explanations on various aspects of the Node.js
environment.

71. How does the libuv library contribute to Node.js?

The libuv library plays a critical role in the performance and behavior of Node.js,
particularly in managing asynchronous I/O operations and event-driven architecture. It is a
multi-platform library that provides a uniform interface for I/O operations and is
responsible for the core features that make Node.js efficient in handling concurrent tasks.

Key Contributions of libuv :

1. Event Loop:

The event loop is the heart of Node.js, and libuv implements this loop, which
allows Node.js to handle multiple concurrent operations efficiently without blocking
the thread.

It enables non-blocking I/O, allowing Node.js to execute I/O operations (like reading
files or querying databases) asynchronously while continuing to process other tasks.

2. Asynchronous I/O:

libuv abstracts system-specific mechanisms (such as epoll on Linux, kqueue on

macOS, and IOCP on Windows) for non-blocking I/O operations, allowing Node.js to
be highly performant in environments with high concurrency.

3. Thread Pool:

libuv uses a thread pool to handle I/O operations that are blocking in nature (e.g.,
file system operations, DNS resolution). While JavaScript runs on a single thread,
libuv offloads some blocking tasks to the thread pool, allowing the main thread
(event loop) to remain free for other operations.

4. Cross-Platform Compatibility:

libuv abstracts platform-specific features, making Node.js applications portable

across various operating systems like Windows, macOS, and Linux without requiring
special handling for OS-specific I/O mechanisms.

In summary, libuv provides the foundation for asynchronous, non-blocking I/O and
concurrency, ensuring that Node.js can handle high levels of traffic and complex operations

67/105
in an efficient and scalable way.

72. How do you implement caching in a Node.js application?

Caching in a Node.js application can significantly improve performance by reducing the
number of requests to databases or external services. Caching can be implemented using
various techniques, such as in-memory caching, file-based caching, or external cache
stores (e.g., Redis or Memcached).

In-Memory Caching:

1. Using a Simple In-Memory Cache:

You can use a JavaScript object or a package like node-cache for basic in-memory
caching.

Example using node-cache :

bash

npm install node-cache

javascript

const NodeCache = require('node-cache');

const cache = new NodeCache();

// Set a cache item

cache.set('user_123', { name: 'John Doe', age: 30 }, 3600); // TTL 1 hour

// Get a cached item

const user = cache.get('user_123');
if (user) {
console.log('Cache hit:', user);
} else {
console.log('Cache miss, fetch data...');
// Fetch data and store it in cache
}

2. Using Redis for Caching:

68/105
 Redis is a popular in-memory data store that can be used to cache data outside the
application process. It is commonly used in distributed systems for high-
performance caching.

Example using Redis:

bash

npm install redis

javascript

const redis = require('redis');

const client = redis.createClient();

// Set cache data with an expiration time (TTL)

client.setex('user_123', 3600, JSON.stringify({ name: 'John Doe', age: 30 }));

// Get cache data

client.get('user_123', (err, reply) => {
if (reply) {
console.log('Cache hit:', JSON.parse(reply));
} else {
console.log('Cache miss');
// Fetch data and cache it
}
});

Other Caching Techniques:

HTTP Caching: Cache HTTP responses using caching headers ( Cache-Control , ETag ,
etc.).

Content Delivery Networks (CDNs): For static assets, CDNs can be used for caching
content globally, reducing latency and server load.

73. Explain the role of a reverse proxy with Node.js.

69/105
A reverse proxy is a server that sits between client devices and a backend server (like a
Node.js application), forwarding client requests to the appropriate backend service. It acts as
an intermediary, ensuring proper request handling, load balancing, security, and caching.

Key Roles of a Reverse Proxy with Node.js:

1. Load Balancing:

A reverse proxy can distribute incoming traffic across multiple instances of a Node.js
application, improving performance and ensuring better resource utilization. This is
particularly important for handling high volumes of requests.

2. SSL Termination:

The reverse proxy can handle SSL/TLS encryption and decryption (SSL termination),
reducing the computational load on the Node.js server by offloading the encryption
task to the proxy.

3. Caching:

A reverse proxy can cache static content (e.g., HTML, images, etc.) and reduce the
load on your Node.js application by serving cached data for repeated requests.

4. Security:

A reverse proxy can act as an additional security layer, filtering out malicious
requests, preventing DDoS attacks, or protecting sensitive endpoints.

5. API Gateway:

Reverse proxies can also serve as an API Gateway, managing requests to multiple
microservices, directing them to different backend services based on routing rules.

6. Scaling:

It enables horizontal scaling by distributing requests to multiple instances of a

Node.js application. This ensures better fault tolerance and scalability.

Example of Reverse Proxy Setup:

Popular reverse proxy tools include NGINX and HAProxy. NGINX can be configured to
forward requests to a Node.js app running on a different port.

Example configuration for NGINX:

nginx

70/105
 server {
listen 80;

server_name example.com;

location / {
proxy_pass http://localhost:3000; # Forward requests to Node.js app
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_cache_bypass $http_upgrade;
}
}

74. How do you use a message queue with Node.js (e.g., RabbitMQ)?
A message queue allows asynchronous communication between services by sending
messages that can be processed later. RabbitMQ is a popular open-source message broker
that supports various messaging patterns, including publish/subscribe, work queues, and
routing.

Using RabbitMQ with Node.js:

To use RabbitMQ with Node.js, you can use the amqplib library, which provides an interface
to interact with RabbitMQ.

1. Install amqplib :

bash

npm install amqplib

2. Producer (Sending Messages): A producer sends messages to a specific queue.

javascript

const amqp = require('amqplib/callback_api');

71/105
 amqp.connect('amqp://localhost', (err, conn) => {
if (err) throw err;
conn.createChannel((err, channel) => {
if (err) throw err;
const queue = 'task_queue';
const msg = 'Hello, RabbitMQ!';

channel.assertQueue(queue, { durable: true });

channel.sendToQueue(queue, Buffer.from(msg), { persistent: true });
console.log(" [x] Sent '%s'", msg);
});
});

3. Consumer (Receiving Messages): A consumer listens for messages from the queue and
processes them.

javascript

const amqp = require('amqplib/callback_api');

amqp.connect('amqp://localhost', (err, conn) => {

if (err) throw err;
conn.createChannel((err, channel) => {
if (err) throw err;
const queue = 'task_queue';

channel.assertQueue(queue, { durable: true });

console.log(" [*] Waiting for messages in %s. To exit press CTRL+C");

channel.consume(queue, (msg) => {

if (msg !== null) {
console.log(" [x] Received %s", msg.content.toString());
channel.ack(msg);
}
}, { noAck: false });
});
});

4. Benefits:

Decoupling: Services are decoupled, making them easier to scale and maintain.

Reliability: RabbitMQ ensures that messages are not lost (durable queues).

72/105
 Asynchronous Processing: RabbitMQ can handle heavy or slow tasks
asynchronously, freeing up resources for other operations.

75. How do you integrate microservices with Node.js?

Integrating microservices in a Node.js environment involves creating multiple small,
independently deployable services that communicate with each other over a network
(typically via HTTP, WebSockets, or messaging queues).

Steps for Integrating Microservices with Node.js:

1. Use REST APIs:

Each microservice exposes a REST API for communication with other services. You
can use Express or other frameworks to create APIs.

2. Service Discovery:

Microservices need to discover and communicate with each other. This can be
achieved using tools like Consul or Eureka, which register microservices and provide
dynamic service discovery.

3. Inter-Service Communication:

HTTP or gRPC (for faster communication) can be used to communicate between

services. For asynchronous communication, a message queue like RabbitMQ or
Kafka can be used.

4. API Gateway:

Use an API Gateway (such as NGINX or Kong) to route incoming requests to the
correct microservice and handle cross-cutting concerns like authentication, rate-
limiting, and logging.

5. Database per Service:

Each microservice should have its own database to ensure loose coupling. This can
be SQL, NoSQL, or a combination, depending on the service's needs.

6. Authentication and Authorization:

Implement JWT ( JSON Web Tokens) for service-to-service authentication or use a

centralized identity provider (e.g., OAuth2).

73/105
Example of Simple Microservice Architecture:

Service 1: User Service (manages users, exposes /users API).

Service 2: Product Service (manages products, exposes /products API).

API Gateway: Routes incoming requests to the appropriate service.

In this architecture, each microservice can be scaled independently based on its load.

These answers provide an overview of key topics related to Node.js and microservices,
helping you better understand how to optimize and scale your applications.

76. Explain the Internals of the Node.js Event Loop and Its Phases.
The Node.js event loop is the core mechanism behind non-blocking, asynchronous
execution in Node.js. It allows Node.js to handle multiple operations (such as I/O, network
requests, and timers) concurrently without blocking the execution thread.

The event loop operates in multiple phases, each with specific tasks. Understanding these
phases is essential to grasp how Node.js processes tasks.

Phases of the Event Loop:

1. Timers Phase:

This phase executes callbacks for setTimeout and setInterval functions. If a

timer's time threshold has passed, its callback is executed.

2. I/O Callbacks Phase:

Executes callbacks for completed I/O operations (like reading files, network
requests, etc.) that were queued in the previous cycle.

3. Idle, Prepare Phase:

This phase is used internally for housekeeping and to prepare for the next cycle. It
does not typically execute application-level code.

4. Poll Phase:

The poll phase is where most I/O events are handled. If there are no timers to
execute, the event loop will block and wait for I/O events. This phase processes I/O
tasks (such as database queries) that are ready for execution. If there are callbacks
to execute, they are processed here.

74/105
 5. Check Phase:

Executes callbacks for setImmediate() calls. This phase happens immediately after
the poll phase, before any new timers are triggered.

6. Close Callbacks Phase:

Handles close events, such as when a socket or handle is closed. This includes
events like socket.on('close') or process.on('exit') .

Event Loop Execution Cycle:

The event loop continuously cycles through these phases. The order of execution is:

Timers -> I/O Callbacks -> Idle/Prepare -> Poll -> Check -> Close Callbacks.

The event loop provides non-blocking concurrency by allowing I/O operations to be handled
without pausing the execution of the program.

77. How Do You Handle High Concurrency in a Node.js Application?

Handling high concurrency efficiently is one of the major benefits of Node.js. Since Node.js
uses a single-threaded event loop, it can handle thousands of simultaneous requests by non-
blocking I/O. However, there are several strategies to further improve its concurrency
handling:

1. Asynchronous I/O:

Use asynchronous non-blocking operations to handle file system, database queries,

network calls, etc., without blocking the event loop. This ensures that Node.js remains
responsive to incoming requests while performing I/O operations.

2. Clustering:

The cluster module allows you to create multiple child processes (workers) running in
parallel. Each worker runs on a separate CPU core, leveraging multi-core systems and
improving concurrency.

Example using cluster :

javascript

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

if (cluster.isMaster) {
// Fork workers for each CPU core
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}
} else {
// Worker code
http.createServer((req, res) => {
res.writeHead(200);
res.end('Hello, world!');
}).listen(8000);
}

3. Load Balancing:

Use a reverse proxy (like NGINX) or a load balancer to distribute incoming requests to
multiple instances of the Node.js application, ensuring no single process is
overwhelmed.

4. Caching:

Implement caching mechanisms (e.g., Redis) to reduce the load on the application by
storing frequently accessed data in memory.

5. Rate Limiting:

Implement rate limiting to prevent clients from overwhelming your server with too
many requests. Tools like Redis and middleware like express-rate-limit can be useful.

6. Use Worker Threads:

For CPU-intensive tasks, consider using worker threads. These allow you to run
operations on separate threads, freeing the main event loop for I/O-bound tasks.

78. What Are Some Advanced Patterns for Error Handling in Node.js?

76/105
Error handling in Node.js is a crucial aspect of ensuring that the application runs reliably,
especially in an asynchronous environment. Here are some advanced patterns for handling
errors:

1. Centralized Error Handling Middleware:

For frameworks like Express, you can use a centralized error-handling middleware. This
pattern helps manage all application errors in a single place, improving maintainability.

Example:

javascript

app.use((err, req, res, next) => {

console.error(err.stack);
res.status(500).send('Something went wrong!');
});

2. Domain Module (Deprecated):

The domain module was used for handling uncaught errors across asynchronous
callbacks. While it's deprecated, it was a useful tool for catching unhandled errors in
multiple callbacks and preventing crashes. Consider using try/catch blocks or other
patterns instead.

3. Promises and .catch() :

In asynchronous code using Promises, use the .catch() method to catch errors at the
end of the chain, ensuring you don't miss exceptions thrown at any point in the chain.

Example:

javascript

someAsyncFunction()
.then(result => { /* process result */ })
.catch(error => { console.error('Error:', error); });

4. Async/Await with Try/Catch:

When using async/await, wrap asynchronous code in try/catch blocks to handle

exceptions synchronously.

Example:

77/105
 javascript

async function someFunction() {

try {
const result = await someAsyncOperation();
console.log(result);
} catch (err) {
console.error('Error:', err);
}
}

5. Graceful Shutdown:

Handle uncaught exceptions and unhandled promise rejections to allow for a graceful
shutdown.

Listen for process.on('uncaughtException') and process.on('unhandledRejection')

to prevent crashes and clean up resources.

Example:

javascript

process.on('uncaughtException', (err) => {

console.error('Uncaught Exception:', err);
process.exit(1); // Exit after logging the error
});

79. How Does Node.js Integrate with WebAssembly?

WebAssembly (Wasm) is a binary instruction format for safe, portable, and high-
performance execution of code in web browsers and other environments, including Node.js.
In Node.js, WebAssembly is used for high-performance computing tasks, such as image
processing, cryptography, or physics simulations.

Integrating WebAssembly in Node.js:

1. Loading a WebAssembly Module:

78/105
 Use the WebAssembly API to load and instantiate WebAssembly modules in Node.js.
This allows you to run compiled code (e.g., C, C++, Rust) within a Node.js process.

Example:

javascript

const fs = require('fs');

const wasmBuffer = fs.readFileSync('example.wasm');

WebAssembly.instantiate(wasmBuffer)
.then(wasmModule => {
const result = wasmModule.instance.exports.add(5, 3);
console.log('Result from WebAssembly:', result); // Output: 8
})
.catch(err => {
console.error('Failed to load WebAssembly module', err);
});

2. Interoperability:

WebAssembly code in Node.js can interact with JavaScript through imports and
exports. You can pass values between JavaScript and WebAssembly modules,
enabling high-performance operations.

3. Use Cases:

Heavy computation: Use WebAssembly for tasks requiring high performance (e.g.,
cryptographic operations).

Third-party libraries: If a library is written in C or Rust, compile it to WebAssembly

and use it in Node.js for improved performance.

80. How Do You Create a Custom Stream in Node.js?

A custom stream in Node.js allows you to define your own streaming behavior by extending
the Readable or Writable stream classes from the stream module.

Creating a Custom Readable Stream:

79/105
You can create a custom stream by extending the Readable stream class and implementing
the _read method, which dictates how data is pushed to the stream.

javascript

const { Readable } = require('stream');

class MyReadableStream extends Readable {

constructor(options) {
super(options);
this.data = ['Hello', 'World', 'from', 'Node.js'];
}

_read(size) {
const chunk = this.data.shift();
if (chunk) {
this.push(chunk);
} else {
this.push(null); // End the stream
}
}
}

const readableStream = new MyReadableStream();

readableStream.pipe(process.stdout);

Creating a Custom Writable Stream:

To create a custom writable stream, extend the Writable class and implement the _write
method, which determines how data is written to the stream.

javascript

const { Writable } = require('stream');

class MyWritableStream extends Writable {

_write(chunk, encoding, callback) {
console.log(`Writing: ${chunk.toString()}`);
callback();
}
}

const writableStream = new MyWritableStream();

80/105
 writableStream.write('Hello');
writableStream.write('World');
writableStream.end();

By creating custom streams, you can handle data in unique ways, such as processing data on
the fly or writing to non-standard outputs.

81. What is the Difference Between C++ Addons and Native Modules in
Node.js?
In Node.js, both C++ Addons and Native Modules allow you to extend the functionality of
Node.js using native code (C++), but there are subtle differences in their context and use.

C++ Addons:

C++ Addons are a way to write native code to extend Node.js using the V8 JavaScript
engine directly. These addons are compiled into binary modules that can be loaded in
Node.js just like regular JavaScript modules.

They allow you to interact with Node.js's internal components and V8 directly, which can
be more efficient for performance-intensive tasks (e.g., computational algorithms or
accessing system-level APIs).

C++ Addons are usually created using Node's N-API (Native API) or nan (a C++ header
file) to facilitate the communication between JavaScript and native C++ code.

Native Modules:

Native Modules generally refer to any modules that involve native bindings or external
dependencies written in a language like C or C++. These modules may include a C++
Addon, but the term "native module" is broader and may also include compiled C++ code
wrapped using bindings like node-gyp.

Node.js's native modules often use binding.gyp files (which are part of the node-gyp
tool) to specify the build process for native code that can be used in Node.js.

Key Difference:

C++ Addons specifically refer to extensions written in C++ that interact with Node.js at
the V8 engine level. Native Modules could refer to any native code bindings to Node.js,
which may include C++, but also C or other languages.

81/105
82. How Do You Implement a Custom Event Emitter in Node.js?
Node.js has a built-in EventEmitter class that allows you to handle events and listeners. To
create a custom event emitter, you can extend this class and define your own events and
behavior.

Example of Custom EventEmitter:

javascript

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

// Register an event listener for 'event'

myEmitter.on('event', () => {
console.log('An event occurred!');
});

// Emit the 'event'

myEmitter.emit('event');

Explanation:

1. Inherit from EventEmitter : You create a custom class (e.g., MyEmitter ) that extends
the EventEmitter class.

2. Emit Events: Use the .emit() method to trigger events.

3. Listen to Events: Use .on() or .once() to listen for the emitted events.

The above example demonstrates how to create and emit a custom event, event , and
handle it using an event listener.

83. How Does Node.js Manage Garbage Collection?

82/105
Node.js uses V8, Google's open-source JavaScript engine, which includes an automatic
garbage collection (GC) mechanism for memory management. Garbage collection ensures
that memory used by objects no longer in use is released, preventing memory leaks.

How Garbage Collection Works in Node.js:

1. Mark-and-Sweep Algorithm:

V8 uses a mark-and-sweep garbage collection technique. In this approach:

Mark phase: V8 identifies all live objects that are referenced (reachable) and
marks them as "in use."

Sweep phase: V8 then clears all objects that are not marked as in use, freeing
their memory.

2. Generational Garbage Collection:

V8 divides the heap into multiple regions (generations). Objects that survive multiple
garbage collection cycles are moved to the old generation, while new objects are
initially allocated in the new generation.

This generational approach helps optimize garbage collection by focusing more

frequently on objects that are short-lived.

3. Triggering GC:

Garbage collection is triggered automatically when the heap reaches certain

thresholds, but it is non-deterministic. Node.js does not provide manual control
over the GC, though you can force a GC through --expose-gc (using global.gc() ).

Managing GC in Node.js:

Developers can optimize GC by reducing object allocations and avoiding circular

references.

Use tools like --inspect to monitor the heap and analyze memory usage.

84. What is the Difference Between Operating System Threads and

Node.js Threads?
In the context of Node.js, the concept of threads is different from how traditional operating
systems manage threads.

83/105
Operating System Threads:

Operating system threads are managed by the OS kernel and are used by processes to
execute multiple tasks concurrently. These threads have their own stack and memory
and can be scheduled by the OS for execution on different CPU cores.

Operating system threads are heavy-weight, meaning they come with their own
memory and resources.

Node.js Threads:

Node.js uses a single-threaded event loop model for handling I/O-bound tasks.
However, it also provides several mechanisms (like worker threads) to handle CPU-
bound tasks in parallel.

Worker Threads: In Node.js, worker threads are a way to run multiple threads
(background threads) in parallel, each with its own JavaScript execution environment.
This allows you to offload CPU-intensive tasks without blocking the event loop.

Example of a worker thread:

javascript

const { Worker, isMainThread, parentPort } = require('worker_threads');

if (isMainThread) {
const worker = new Worker( filename);
worker.on('message', (message) => console.log(message));
worker.postMessage('Hello from main thread');
} else {
parentPort.on('message', (message) => {
console.log(message);
parentPort.postMessage('Hello from worker thread');
});
}

Key Difference:

Operating system threads are managed by the OS and are typically used by native
applications for parallelism. In contrast, Node.js threads (via worker threads) are a
feature that allows CPU-bound tasks to run in parallel without blocking the event loop,
but they still share the same process.

84/105
85. Explain the tick and microtask Queues in Node.js.
The tick and microtask queues are part of Node.js's event loop mechanism and help
manage the execution order of asynchronous operations.

Tick Queue:

The tick queue is where Node.js schedules operations like setImmediate or

process.nextTick . These are low-priority callbacks that need to be executed after the
current operation but before I/O events (if there are any).

process.nextTick() callbacks are executed before I/O events and microtasks.

Microtask Queue:

The microtask queue is where Promised-based callbacks (i.e., .then() , .catch() , and
async functions) are placed for execution.

Microtasks have a higher priority than other events in the event loop and are executed
after the current operation completes but before the next event loop phase begins.

Execution Order:

The order of execution in the event loop is as follows:

1. Timers (e.g., setTimeout , setInterval )

2. I/O Callbacks

3. process.nextTick (executed before microtasks)

4. Microtasks (like promises)

5. Check Phase ( setImmediate )

Key Difference:

nextTick queue has the highest priority and is executed first, even before microtasks.

Microtasks are executed before the event loop continues to the next phase.

These explanations provide a comprehensive understanding of advanced Node.js concepts,

helping you navigate complex scenarios effectively.

85/105
86. How Do You Analyze and Optimize a Node.js Application's CPU
Usage?
To analyze and optimize CPU usage in a Node.js application, you can employ the following
techniques:

1. Analyzing CPU Usage:

Node.js Profiling:

Use node --inspect or node --inspect-brk to start the application with

debugging enabled. This can be paired with Chrome DevTools to profile the
application's CPU usage.

Use console.profile() and console.profileEnd() to measure the CPU time

consumed by different parts of the code.

Use clinic.js for in-depth profiling of your Node.js application. It provides a

toolset ( clinic doctor , clinic flame , etc.) for detailed analysis.

Process Monitoring:

Use system monitoring tools like top , htop , or pm2 to track CPU usage in real-
time.

Consider using tools like node-heapdump and node-inspect to gather insights on

memory consumption and CPU bottlenecks.

2. Optimizing CPU Usage:

Offload CPU-Intensive Tasks:

Use worker threads to offload CPU-bound tasks, ensuring that the event loop isn't
blocked.

Use child_process to fork separate processes for tasks that are CPU-heavy.

Reduce Synchronous Code:

Avoid synchronous I/O operations like fs.readFileSync or fs.writeFileSync as

they block the event loop. Instead, use asynchronous I/O operations like
fs.readFile .

Use Efficient Algorithms:

Review and optimize algorithms to reduce complexity, such as using memoization

or dynamic programming for frequently computed values.

86/105
 Code Splitting and Caching:

Consider caching expensive operations, reducing redundant computations.

For CPU-bound tasks, use a cache layer like Redis or an in-memory cache.

87. What Are Advanced Use Cases of the child_process Module?

The child_process module is versatile and enables Node.js to spawn child processes to
handle various tasks. Advanced use cases include:

1. Offloading CPU-Intensive Tasks:

Use child processes to offload long-running CPU-intensive computations (e.g., image

processing, complex algorithms) to prevent blocking the event loop.

This allows Node.js to remain responsive while CPU-bound tasks run in parallel.

2. Running External Commands and Shell Scripts:

Use exec or spawn to run external programs, shell scripts, or command-line utilities
like FFmpeg, ImageMagick, etc., from within a Node.js application.

Example:

javascript

const { exec } = require('child_process');

exec('ls -l', (error, stdout, stderr) => {
if (error) {
console.error(`exec error: ${error}`);
return;
}
console.log(`stdout: ${stdout}`);
});

3. Parallel Task Execution:

Use fork for inter-process communication (IPC) between Node.js processes. For
example, you can use child processes for parallel data processing across multiple CPU
cores.

87/105
 Node.js's cluster module can be used in combination with child processes to scale
applications across multiple CPU cores for better performance.

4. Handling Multiple I/O Operations:

Use spawn to initiate background processes for tasks like downloading large files,
managing queues, or interacting with databases in parallel, without affecting the event
loop.

5. Managing Microservices:

Use child processes to run microservices in separate Node.js processes. This allows
different services to be isolated and scaled independently.

88. How Do You Build a Node.js Application with Zero-Downtime

Deployment?
Zero-downtime deployment ensures that your Node.js application remains online during
updates or changes. Here are key strategies for achieving zero-downtime deployment:

1. Use a Process Manager:

PM2 is a popular process manager for Node.js that supports zero-downtime

deployment. It can restart your application with minimal disruption using a graceful
restart.

Example:

bash

pm2 start app.js --watch

pm2 reload app.js --update-env

Graceful restart ensures that old instances finish their ongoing requests before
being terminated, while new instances start processing requests.

2. Blue-Green Deployment:

Maintain two separate environments: one for the current version ( blue ) and one for the
new version ( green ).

88/105
 Switch traffic from the old version to the new version once it's fully deployed and tested.

3. Rolling Deployment:

Deploy new versions of your application incrementally, ensuring that only a subset of the
application is updated at any time.

This can be managed through Kubernetes, Docker, or a load balancer like NGINX.

4. Load Balancing and Canary Releases:

Use a load balancer to distribute traffic across multiple instances of the application.

Perform canary releases by deploying the new version to a small subset of users and
monitoring performance before a full rollout.

89. Explain How Node.js Executes JavaScript Code Internally

Node.js executes JavaScript code using the V8 JavaScript engine, which is part of Google
Chrome. The process involves several key steps:

1. Parsing:

The V8 engine first parses the JavaScript code into an Abstract Syntax Tree (AST).
This step checks for syntax errors and converts the code into a data structure that
can be easily manipulated.

2. Compilation:

V8 then compiles the parsed code into machine code (native code) using just-in-
time ( JIT) compilation. This process helps to optimize performance by converting
the code into executable machine instructions that can be executed directly by the
CPU.

3. Execution:

The generated machine code is executed by the V8 engine. This process also
includes managing scopes, variables, and the event loop.

4. Event Loop:

While the code executes, asynchronous callbacks are managed by the event loop.
This allows Node.js to handle multiple I/O-bound tasks (like reading from a file or
handling HTTP requests) concurrently without blocking the main thread.

89/105
90. What Are Advanced Patterns for Implementing Middleware in
Node.js?
Middleware in Node.js refers to functions that have access to the request and response
objects in an application. They are used for handling common tasks like authentication,
logging, error handling, and data parsing.

Here are some advanced patterns for implementing middleware:

1. Composing Middleware:

You can create composable middleware functions that are organized in pipelines,
allowing you to separate concerns and create reusable middleware logic.

Example:

javascript

const middleware1 = (req, res, next) => {

console.log('Middleware 1');
next();
};

const middleware2 = (req, res, next) => {

console.log('Middleware 2');
next();
};

app.use(middleware1);
app.use(middleware2);

2. Asynchronous Middleware:

Middleware functions can be asynchronous. Use async/await to handle asynchronous

operations like fetching data or interacting with databases.

Example:

javascript

const asyncMiddleware = async (req, res, next) => {

try {
const result = await someAsyncOperation();

90/105
 req.someData = result;
next();
} catch (error) {
next(error);
}
};

3. Error Handling Middleware:

In Express-like frameworks (even without Express), a specialized error-handling

middleware can catch errors and handle them in a centralized way.

Example:

javascript

const errorHandler = (err, req, res, next) => {

console.error(err);
res.status(500).send('Something went wrong!');
};
app.use(errorHandler);

4. Conditional Middleware:

Sometimes, middleware should be applied conditionally, based on the request or

environment.

Example:

javascript

const conditionalMiddleware = (req, res, next) => {

if (req.path.startsWith('/admin')) {
console.log('Admin middleware');
}
next();
};

5. Chaining Middleware with Promises:

Middleware functions can return promises, and they can be chained. This is useful for
operations like database queries or external API calls.

Example:

91/105
 javascript

const asyncMiddleware = (req, res, next) => {

someAsyncFunction(req)
.then(() => next())
.catch(next);
};

By using these patterns, you can create flexible, scalable, and reusable middleware for
handling various aspects of your Node.js application.

91. How Does Node.js Interact with Native Code Libraries?

Node.js can interact with native code libraries (e.g., C, C++, or other languages) through
Native Addons and the N-API.

Native Addons:

Node.js Native Addons are dynamically linked shared objects that extend the
functionality of Node.js with native code. These addons allow Node.js to call native
methods, access system libraries, or perform CPU-intensive operations efficiently.

You can write native code (C or C++) and compile it into a shared library (e.g., .node
files), which can be loaded into your Node.js application.

Steps for creating and using native addons:

1. Use node-gyp to compile C++ code into native modules.

2. Write a C++ binding file that exposes functions from the native code.

3. Use require() to load the compiled addon into your JavaScript code.

Example of loading a native addon:

javascript

const myAddon = require('./build/Release/myaddon.node');

console.log(myAddon.add(1, 2)); // Calls a native function

N-API:

N-API is an API for building native Node.js modules that abstracts the complexities of
different Node.js versions. It helps ensure that native modules work across different
versions of Node.js without needing recompilation.

92/105
 Example:

cpp

#include <node_api.h>
napi_value Add(napi_env env, napi_callback_info info) {
// Implementation of native function
}

NAPI_MODULE(NODE_GYP_MODULE_NAME, Init);

By using native addons or N-API, you can achieve high-performance, low-level system
interaction with Node.js.

92. What Are Advanced Strategies for Scaling Node.js Applications?

Scaling a Node.js application involves ensuring that it can handle more traffic and large
datasets without performance degradation. Here are some advanced strategies:

1. Load Balancing:

Distribute incoming HTTP requests across multiple instances of your application to

ensure that no single process or server becomes overloaded. Tools like NGINX,
HAProxy, or AWS Elastic Load Balancing can help with this.

In a multi-core system, Node.js can scale horizontally by running multiple processes,

each on a different core.

2. Clustering:

Use the cluster module to take advantage of multiple CPU cores. This allows you to
run multiple Node.js processes that share the same server port, balancing the load
across them.

Example:

javascript

const cluster = require('cluster');

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

93/105
 if (cluster.isMaster) {
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}
} else {
http.createServer((req, res) => {
res.writeHead(200);
res.end('Hello, Node.js!');
}).listen(8000);
}

3. Microservices Architecture:

Split your application into smaller, independent microservices that can be scaled
individually. Each service can be deployed on a separate server or container.

Use Docker or Kubernetes to orchestrate and scale microservices efficiently.

4. Asynchronous Processing:

Offload time-consuming tasks (like image processing, data analysis, etc.) to background
queues using Worker Threads or external tools like Redis or RabbitMQ.

Use Message Queues for scaling asynchronous operations.

5. Caching:

Use caching layers like Redis or Memcached to reduce load on your database and
improve response times for frequently requested data.

Cache heavy computational results or static resources (e.g., HTML pages, images).

6. Edge Computing and Content Delivery Networks (CDNs):

Move static assets (e.g., images, JavaScript files) to CDNs or edge servers closer to the
users, which helps reduce latency and offloads your primary server.

7. Rate Limiting:

Protect your application from abuse by implementing rate-limiting strategies to control

the number of requests a client can make within a specific time frame.

8. Horizontal and Vertical Scaling:

Horizontal Scaling: Deploy your application across multiple servers or containers.

94/105
 Vertical Scaling: Increase resources (CPU, memory) on a single server to handle higher
loads.

93. How Do You Implement a Custom Node.js Worker Pool?

A worker pool is useful for managing a set of workers that perform tasks concurrently. Here’s
how you can implement a simple worker pool in Node.js using Worker Threads:

Steps:

1. Create Worker Thread File: Create a file (e.g., worker.js ) that performs a task. This will
be executed by each worker.

javascript

// worker.js
const { parentPort } = require('worker_threads');
parentPort.on('message', (task) => {
const result = task * 2; // Example task
parentPort.postMessage(result);
});

2. Create Worker Pool: Use the worker_threads module to spawn multiple workers and
manage them.

javascript

const { Worker } = require('worker_threads');

class WorkerPool {
constructor(size, workerFile) {
this.size = size;
this.workerFile = workerFile;
this.workers = [];
this.queue = [];
this.busyWorkers = 0;

for (let i = 0; i < size; i++) {

this.workers.push(new Worker(workerFile));
}

95/105
 }

execute(task, callback) {
if (this.busyWorkers < this.size) {
this._dispatchTask(task, callback);
} else {
this.queue.push({ task, callback });
}
}

_dispatchTask(task, callback) {
this.busyWorkers++;
const worker = this.workers[this.busyWorkers - 1];
worker.once('message', (result) => {
callback(null, result);
this.busyWorkers--;
if (this.queue.length > 0) {
const { task, callback } = this.queue.shift();
this._dispatchTask(task, callback);
}
});
worker.postMessage(task);
}
}

// Usage
const pool = new WorkerPool(4, './worker.js');
pool.execute(10, (err, result) => console.log(result)); // Output: 20

By implementing a worker pool, you can efficiently handle concurrent tasks without
overwhelming the main event loop.

94. How Do You Create a Node.js CLI Tool from Scratch?

Creating a Node.js CLI tool involves setting up a basic Node.js project, writing the
functionality, and allowing it to be executed from the command line.

Steps:

96/105
1. Set Up Project:

Initialize your project with npm init .

Create a main JavaScript file (e.g., cli.js ).

2. Parse Command Line Arguments:

Use built-in process.argv or a package like yargs or commander to handle

command-line arguments.

Example using yargs :

javascript

const yargs = require('yargs');

yargs.command('greet <name>', 'Greet a person', (yargs) => {

yargs.positional('name', {
describe: 'The name to greet',
type: 'string',
});
}, (argv) => {
console.log(`Hello, ${argv.name}!`);
})
.help()
.argv;

3. Make the CLI Executable:

Add a shebang line (#!/usr/bin/env node ) at the top of the script to make it
executable as a CLI tool.

Set the "bin" field in package.json to map the command to the script.

Example package.json :

json

"bin": {
"greet": "./cli.js"
}

4. Publish the Tool:

Optionally, you can publish your CLI tool to npm for others to use.

97/105
 Run npm link to test locally.

95. What Is the Role of the Repl Module in Node.js, and How Do You
Use It?
The repl (Read-Eval-Print Loop) module in Node.js provides an interactive shell where you
can execute JavaScript code and see the results immediately. It is primarily used for testing
small code snippets, debugging, or experimenting with APIs in a live environment.

Role:

It allows you to interact with your Node.js environment in a simple, interactive console. It
can evaluate expressions, execute code, and print results in real-time.

How to Use:

1. Basic REPL:

In a terminal, you can run node without any arguments to start the REPL.

Example:

bash

$ node
> console.log("Hello, Node.js!");
Hello, Node.js!

2. Custom REPL in Code: You can also create a custom REPL using the repl module to
define specific behavior.

Example:

javascript

const repl = require('repl');

const server = repl.start({

prompt: 'MyCustomPrompt> ',
eval: (cmd, context, filename, callback) => {
callback(null, eval(cmd)); // Custom evaluation logic
},

98/105
 });

server.on('exit', () => {
console.log('REPL exited');
});

The REPL module is a powerful tool for experimentation and debugging, especially when
learning or prototyping in Node.js.

96. How Do You Write Tests for Node.js Using Advanced Mocking
Techniques?
In Node.js, writing tests typically involves using testing frameworks such as Mocha, Jest, or
Jasmine. Mocking is used to simulate the behavior of external dependencies (e.g., databases,
APIs, or other services) to test units of your code in isolation.

Steps for Advanced Mocking:

1. Use a Mocking Library: Libraries like Sinon.js, jest.mock(), or proxyquire are commonly
used for mocking.

Sinon.js allows for creating mocks, stubs, and spies, which you can use to control
and track function calls during tests.

Jest offers built-in mocking functions, including jest.fn() , jest.mock() , and

jest.spyOn() for intercepting and mocking modules.

2. Mocking Dependencies:

Use Sinon’s spies and stubs to replace real functions with mock functions in your
unit tests.

Example with Sinon:

javascript

const sinon = require('sinon');

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

describe('My Function', () => {

it('should call the external API', () => {
const fakeApi = sinon.stub(myModule, 'externalApiCall').returns('mocked
data');
const result = myModule.myFunction();

99/105
 expect(result).toEqual('mocked data');
fakeApi.restore(); // Restore original behavior
});
});

3. Mocking Modules with proxyquire :

Proxyquire allows you to mock the dependencies of the module being tested.

Example with Proxyquire:

javascript

const proxyquire = require('proxyquire');

const myModule = proxyquire('./myModule', {
'./externalApi': { getData: () => 'mocked response' }
});

describe('myModule', () => {
it('should use the mocked API', () => {
const result = myModule.fetchData();
expect(result).toBe('mocked response');
});
});

4. Mocking Time:

Mocking setTimeout, setInterval, or other time-related functions can be done with

sinon.useFakeTimers() or jest.useFakeTimers().

Example:

javascript

jest.useFakeTimers();
const callback = jest.fn();
setTimeout(callback, 1000);
jest.runAllTimers(); // Fast-forward the timers
expect(callback).toHaveBeenCalled();

100/105
97. What Are Best Practices for Securing a Node.js Application?
Securing a Node.js application is critical to prevent unauthorized access, data leaks, and
other vulnerabilities. Here are some best practices:

1. Keep Dependencies Up-to-Date:

Regularly update dependencies to avoid known security vulnerabilities. Use tools like
npm audit or Snyk to detect vulnerabilities in your dependencies.

2. Input Validation and Sanitization:

Always validate and sanitize user inputs to prevent injection attacks (e.g., SQL injection,
NoSQL injection, Cross-Site Scripting (XSS)).

3. Use HTTPS:

Always use HTTPS instead of HTTP to encrypt data in transit. Tools like Let’s Encrypt can
provide free SSL certificates.

4. Avoid Storing Sensitive Information:

Do not store sensitive data like passwords or API keys in plaintext. Use hashing (e.g.,
bcrypt for passwords) and encryption to secure sensitive information.

5. Implement Authentication & Authorization:

Use secure methods like JWT ( JSON Web Tokens) or OAuth for authentication and
authorization.

Enforce strict access controls based on roles and permissions.

6. Secure Your API Endpoints:

Implement rate-limiting (e.g., express-rate-limit) to prevent DDoS attacks.

Use CORS policies to restrict access to trusted domains.

7. Use Helmet for Security Headers:

Helmet is a middleware that helps set various HTTP headers to secure your application
(e.g., X-Content-Type-Options , Strict-Transport-Security ).

Example:

javascript

101/105
 const helmet = require('helmet');
app.use(helmet());

8. Error Handling:

Avoid revealing stack traces or detailed error messages to users in production. Use a
logging library (e.g., Winston) to record detailed logs for debugging.

9. Secure Session Management:

Use secure cookies, and implement session expiration to prevent session fixation or
hijacking attacks.

98. How Does Node.js Interact with the Operating System’s Network
Stack?
Node.js interacts with the operating system's network stack primarily through its net and
http modules. It uses the libuv library, which provides a cross-platform abstraction over the

OS's networking functionality.

Network Interaction Flow:

1. TCP/UDP Sockets: The net module allows Node.js to create TCP or UDP servers and
clients. When you create a socket (e.g., net.createServer() ), libuv abstracts and
interacts with the OS’s network stack to establish the connection.

2. HTTP/HTTPS Requests: Node.js’s http and https modules internally handle the
creation and parsing of HTTP/HTTPS requests, utilizing underlying OS network
functionality to manage connections, headers, and data transfers.

3. Event Loop: Node.js uses its event-driven architecture and libuv’s event loop to handle
network events asynchronously. When a network event occurs (e.g., data received on a
socket), libuv pushes that event into the event loop, and Node.js processes it
asynchronously.

4. DNS Resolution: Node.js uses the operating system’s DNS resolver to handle domain
name lookups when making HTTP requests or when establishing socket connections.

102/105
99. How Do You Use the inspector Module for Advanced Debugging in
Node.js?
The inspector module in Node.js allows you to perform advanced debugging using the
Chrome DevTools or any other debugging tools that support the V8 Inspector Protocol.

How to Use:

1. Start the Inspector: You can start the Node.js application with the --inspect or --
inspect-brk flag to enable debugging.

--inspect : Starts the debugger without pausing at the first line.

--inspect-brk : Starts the debugger and pauses at the first line of code.

Example:

bash

node --inspect app.js

2. Connect with Chrome DevTools:

Open Chrome and navigate to chrome://inspect .

Click on "Inspect" under "Remote Targets" to connect to your Node.js process and
start debugging.

3. Remote Debugging:

You can also use the Node.js inspector remotely (e.g., through a VS Code or another
IDE).

4. Programmatic Access: You can programmatically control the inspector using the
inspector module.

Example:

javascript

const inspector = require('inspector');

inspector.open(9229, '127.0.0.1', true);

This allows you to open the debugging port and make API calls to interact with the
debugger.

103/105
100. How Do You Implement Distributed Systems with Node.js?
Node.js can be used to implement distributed systems by breaking the application into
smaller, independent services (microservices) that communicate with each other.

Key Components:

1. Message Queues:

Use RabbitMQ, Kafka, or Redis Pub/Sub to facilitate communication between

microservices in a distributed system.

Queue-based systems can ensure reliable delivery of messages even in the event of
failure.

2. Service Discovery:

Consul or Eureka can be used for service discovery, allowing services to register and
discover each other dynamically.

3. Cluster Module:

Use the cluster module to scale a Node.js application horizontally across multiple
processes and cores. This helps handle high concurrency.

4. API Gateway:

Implement an API gateway (e.g., Kong, API Gateway in AWS) to provide a single
entry point for the client, routing requests to the appropriate microservices.

5. Stateful Services:

Distributed systems often require managing state. Use distributed databases (e.g.,
Cassandra, MongoDB) and shared cache systems (e.g., Redis) to handle distributed
data storage and caching.

6. Containerization:

Containerize Node.js microservices using Docker. Containers allow for isolation,

scalability, and easier deployment of services.

7. Fault Tolerance and Replication:

Implement strategies for fault tolerance, such as circuit breakers (e.g., Hystrix) and
retry logic to ensure that your system can handle service failures gracefully.

8. Load Balancing:

Use load balancers (e.g., NGINX, HAProxy) to distribute traffic evenly across multiple
service instances.

104/105
By leveraging Node.js's asynchronous I/O, event-driven architecture, and external tools like
message queues and service discovery, you can build efficient and scalable distributed
systems.

105/105