NodeJs Interview Questions

Node.js is an open-source, cross-platform JavaScript runtime environment that allows JavaScript to run outside the browser. It is built on Chrome's V8 engine and follows a non-blocking, event-driven architecture, making it ideal for scalable, real-time, and high-performance applications.

Why use Node.js?

1. Asynchronous & Non-blocking I/O for high performance

2. Single-threaded but handles multiple requests efficiently

3. Fast execution due to V8 engine

4. Ideal for APIs, real-time apps, and microservices

ESLint can be used with any IDE to ensure a consistent coding style which further helps in maintaining the codebase.

Example:

Synchronous (Blocking):

const fs = require('fs');
const data = fs.readFileSync('file.txt', 'utf8');
console.log(data); // Waits for file reading
console.log("This runs after file read");

Asynchronous (Non-Blocking):

fs.readFile('file.txt', 'utf8', (err, data) => {
    console.log(data);  // Runs later
});
console.log("This runs first");

It can be managed by a number of package installers and their configuration file accordingly. Out of them mostly use npm or yarn. Both provide almost all libraries of javascript with extended features of controlling environment-specific configurations. To maintain versions of libs being installed in a project we use package.json and package-lock.json so that there is no issue in porting that app to a different environment.

Streams are data-handling objects in Node.js that allow reading/writing data efficiently in chunks instead of loading it all at once.

Types of Streams:

1. Readable Streams → fs.createReadStream() (e.g., reading a file)

2. Writable Streams → fs.createWriteStream() (e.g., writing to a file)

3. Duplex Streams → Readable & Writable (e.g., TCP sockets)

4. Transform Streams → Modify data while reading/writing (e.g., compression)

Example: Read a file using streams:

const fs = require('fs');
const readStream = fs.createReadStream('data.txt', 'utf8');

readStream.on('data', (chunk) => {
    console.log(chunk);  // Reads data in chunks
});

A callback function is called after a given task. It allows other code to be run in the meantime and prevents any blocking. Being an asynchronous platform, Node.js heavily relies on callback. All APIs of Node are written to support callbacks.

Middleware functions in Express.js are functions that execute during request processing before sending a response.

Types of Middleware:

1. Application-level middleware : app.use((req, res, next) => {...})

2. Router-level middleware : router.use(...)

3. Error-handling middleware : (err, req, res, next) => {...}

4. Built-in middleware : express.json(), express.static()

Example:

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

// Middleware function
app.use((req, res, next) => {
    console.log('Request received:', req.method, req.url);
    next();  // Pass to next middleware
});

app.get('/', (req, res) => {
    res.send('Hello, Express!');
});

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

Node.js is widely used in the following applications:

1. Real-time chats

2. Internet of Things

3. Complex SPAs (Single-Page Applications)

4. Real-time collaboration tools

5. Streaming applications

6. Microservices architecture

Clustering allows Node.js to create multiple processes (workers) on multi-core CPUs, improving performance.

Example using cluster module:

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

if (cluster.isMaster) {
    // Fork workers
    os.cpus().forEach(() => cluster.fork());
} else {
    http.createServer((req, res) => {
        res.writeHead(200);
        res.end('Hello from Worker ' + process.pid);
    }).listen(3000);
}

Each worker runs independently but shares the same port.

Modules are like JavaScript libraries that can be used in a Node.js application to include a set of functions. To include a module in a Node.js application, use the require() function with the parentheses containing the module's name.

Node.js has many modules to provide the basic functionality needed for a web application. Some of them include:

1. Try-Catch (for synchronous errors)

2. Event Listeners (process.on('uncaughtException'))

3. Promises (.catch())

4. Async/Await (try...catch)

Example:

try {
    throw new Error("Something went wrong!");
} catch (error) {
    console.error(error.message);
}

Event loops handle asynchronous callbacks in Node.js. It is the foundation of Node.js's non-blocking input/output in Node.js, making it one of the most important environmental features.

The two types of API functions in Node.js are:

1. Asynchronous, non-blocking functions

2. Synchronous, blocking functions

HTTP defines a set of request methods used to perform desired actions. The request methods include:

1. GET : Used to retrieve the data

2. POST : Generally used to make a change in state or reactions on the server

3. HEAD : Similar to the GET method, but asks for the response without the response body

4. DELETE : Used to delete the predetermined resource

Global objects in Node.js are objects that are available in all modules without the need for an explicit require statement. Some of the most commonly used global objects in Node.js include process, console, and buffer.

Middleware is a function that receives the request and response objects. Most tasks that the middleware functions perform are:

1. Execute any code

2. Update or modify the request and the response objects

3. Finish the request-response cycle

4. Invoke the next middleware in the stack

The setTimeout() method schedules code execution after a specified delay, measured in milliseconds. On the other hand, the setImmediate() method schedules code execution to occur immediately after the current event loop iteration completes. This means that setImmediate() has a higher priority than setTimeout().