Node.js Interview Master

Node.js is a cross-platform, open-source JavaScript runtime environment that executes JavaScript code outside a web browser. It is built on Google Chr...

Yes, Node.js is primarily single-threaded for its event loop, but it uses internal worker threads (via libuv) for handling expensive I/O operations li...

JavaScript is a programming language, whereas Node.js is a runtime environment that allows you to run JavaScript on the server side.

npm (Node Package Manager) is the default package manager for Node.js. It allows developers to share and reuse code and manage project dependencies.

REPL stands for Read-Eval-Print Loop. It is an interactive shell that takes user inputs, executes them, and prints the result, useful for testing smal...

Core modules include 'fs' (file system), 'http' (creating servers), 'path' (handling file paths), 'os' (operating system info), and 'events' (event em...

Using the 'http' module: `http.createServer((req, res) => { res.end('Hello'); }).listen(3000);`

It is the manifest file for a Node.js project. It contains metadata about the project, script definitions, and lists of dependencies and devDependenci...

`require` is CommonJS syntax used in Node.js by default. `import` is ES6 module syntax. Node.js supports both, but ES6 requires `.mjs` extension or `"...

A callback is a function passed as an argument to another function, which is executed after some operation (usually asynchronous) is completed.

The Event Loop is a mechanism that allows Node.js to perform non-blocking I/O operations by offloading tasks to the system kernel whenever possible.

`setImmediate()` is designed to execute a script once the current poll phase completes. `setTimeout()` schedules a script to be run after a minimum th...

It is used to define what a module exports so that it can be used in other files using `require()`.

It is an array containing the command-line arguments passed when the Node.js process was launched.

It means that Node.js doesn't wait for an I/O operation (like reading a file) to finish before moving to the next task. Instead, it provides a callbac...

The `fs` (File System) module allows you to interact with the file system on your computer (reading, writing, deleting files).

It occurs when multiple nested callbacks make the code hard to read and maintain. It's often solved using Promises or Async/Await.

A Promise is an object representing the eventual completion (or failure) of an asynchronous operation and its resulting value.

It is a syntactic sugar built on top of Promises that allows you to write asynchronous code that looks and behaves like synchronous code.

Unlike the browser's `window` object, Node.js has a `global` object. Common globals include `process`, `__dirname`, and `__filename`.

`__dirname` is the directory name of the current module. `__filename` is the absolute path of the current module file.

The 'path' module provides utilities for working with file and directory paths (e.g., `path.join()`, `path.extname()`).

It is a pattern where the first argument of a callback is an error object (if any), and the second argument is the result data.

Using `npm install <package>@<version>` (e.g., `npm install express@4.17.1`).

`dependencies` are required for the application to run. `devDependencies` are only needed for development and testing (e.g., nodemon, jest).

Nodemon is a tool that automatically restarts the Node.js application when file changes in the directory are detected.

It is a paradigm where the flow of the program is determined by events such as user actions, sensor outputs, or messages from other programs.

A class in the 'events' module used to handle custom events. You can 'emit' events and 'listen' for them using `.on()`.

A Buffer is a way to handle binary data in Node.js, specifically used to deal with streams of binary data.

The `os` module provides operating system-related utility methods like `os.platform()`, `os.cpus()`, and `os.totalmem()`.

Streams are objects that let you read data from a source or write data to a destination in a continuous fashion.

Four types: Readable, Writable, Duplex (both read/write), and Transform (modify data while reading/writing).

Piping is a mechanism to connect the output of a readable stream directly to the input of a writable stream (e.g., `src.pipe(dest)`).

Chaining is a mechanism to connect multiple stream operations together (e.g., pipe to zip, then pipe to write file).

It is a utility that takes a function following the common error-first callback style and returns a version that returns a promise.

Express is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications.

Middleware functions are functions that have access to the request object (req), the response object (res), and the next middleware function in the ap...

Using `app.get()`, `app.post()`, `app.put()`, `app.delete()` etc., or using `express.Router()` for modular routes.

Initially a separate middleware, now built into Express (`express.json()`). It parses incoming request bodies in a middleware before your handlers.

REST (Representational State Transfer) is an architectural style for designing networked applications using standard HTTP methods.

JSON (JavaScript Object Notation) is a lightweight data-interchange format that is easy for humans to read/write and easy for machines to parse/genera...

`cors` is a Node.js package for providing a Connect/Express middleware that can be used to enable CORS (Cross-Origin Resource Sharing) with various op...

`dotenv` is a zero-dependency module that loads environment variables from a `.env` file into `process.env`.

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js. It manages relationships between data, provides schema validation, etc.

JWT (JSON Web Token) is a compact, URL-safe means of representing claims to be transferred between two parties.

Commonly using libraries like 'multer' which handles 'multipart/form-data'.

Bcrypt is a library used to hash passwords securely before storing them in a database.

Checking if the input data meets certain criteria (e.g., email format, required fields). Libraries like 'Joi' or 'express-validator' are common.

`undefined` means a variable has been declared but has not yet been assigned a value. `null` is an assignment value representing no value.

Hoisting is a JavaScript mechanism where variables and function declarations are moved to the top of their containing scope before code execution.

Phases include: Timers (setTimeout), Pending Callbacks, Idle/Prepare, Poll (incoming I/O), Check (setImmediate), and Close Callbacks.

Microtasks (process.nextTick, Promises) run after the current operation finishes and before the next Event Loop phase. Macrotasks (setTimeout, setImme...

`process.nextTick()` adds a callback to the 'next tick queue'. This queue is processed after the current operation completes, regardless of the curren...

Node.js uses an event-driven, non-blocking I/O model. It uses a single thread to handle many connections concurrently by offloading I/O to the kernel/...

The 'cluster' module allows you to create child processes (workers) that share the same server port, enabling your app to use all available CPU cores.

The `worker_threads` module enables the use of threads that execute JavaScript in parallel, useful for CPU-intensive tasks without blocking the event ...

Cluster creates separate instances of the entire Node.js process (different memory). Worker threads run in the same process and share memory (via Shar...

Using heap dumps, Chrome DevTools, and monitoring tools to find growing objects that aren't being garbage collected (e.g., global variables, forgotten...

Backpressure occurs when data is written to a stream faster than it can be consumed. Node.js handles this by pausing the readable stream when the writ...

Libuv is a multi-platform C library that provides support for asynchronous I/O based on event loops. It handles the thread pool, file system, and netw...

Using 'helmet' for security headers, rate limiting, data validation, avoiding 'eval()', keeping dependencies updated, and using HTTPS.

Authentication is verifying who a user is (e.g., login). Authorization is verifying what a user is allowed to do (e.g., access levels).

Horizontal scaling (adding more servers/instances with Load Balancers) and Vertical scaling (adding more CPU/RAM).

PM2 is a production process manager for Node.js applications. It provides features like auto-restart, cluster mode, and monitoring.

Socket.io is a library that enables real-time, bi-directional, and event-based communication between the browser and the server.

Redis is an in-memory data store commonly used as a cache, session store, or message broker to improve performance.

Spy: tracks calls to a function. Stub: replaces a function with a version that returns fixed data. Mock: fake object with pre-programmed expectations.

Listening for SIGTERM/SIGINT signals, stopping the server from accepting new requests, and finishing existing ones before exiting.

An approach to software development that centers the design on a core domain model, fostering a common language between tech and business.

Designing an application as a collection of small, independent services that communicate over APIs (e.g., via HTTP or RabbitMQ).

Using tools like OpenTelemetry, Jaeger, or Zipkin to track requests as they move across different microservices.

A pattern where the state of the application is determined by a sequence of events, rather than just the current state in a DB.

Command Query Responsibility Segregation—splitting read operations (Queries) and write operations (Commands) into different models.

Adding indexes, using projections (selecting only needed fields), pagination, and caching results in Redis.

The process of making statically rendered HTML interactive on the client side by attaching event listeners.

Using a Load Balancer (Nginx), horizontal scaling, and ensuring the application is stateless.

V8 uses a generational collector (Scavenge for young objects, Mark-Sweep-Compact for old objects) to reclaim memory.

Stack is for static data (primitive values, function calls). Heap is for dynamic data (objects, arrays).

A vulnerability where an attacker manipulates the `__proto__` property to inject properties into all objects in the application.

Used for cryptographic operations like hashing, HMAC, encryption/decryption, and digital signatures.

Authentication middleware for Node.js. It supports various 'strategies' like OAuth, Local (username/password), etc.

Using 'multipart upload' and 'presigned URLs' to allow the client to upload directly to S3 securely.

Deploying individual functions (Lambdas) that run in response to events, without managing the underlying server infrastructure.

The delay that occurs when a serverless function is triggered for the first time or after a period of inactivity.

A high-performance RPC framework that uses Protocol Buffers and HTTP/2 for efficient cross-service communication.

A query language for APIs that allows clients to request exactly the data they need and nothing more.

REST has multiple endpoints and can suffer from over-fetching/under-fetching. GraphQL has a single endpoint and flexible queries.

Using 'offset-based' or 'cursor-based' (preferred for large data) pagination to limit result sizes.

Redis-based message queue libraries used for handling background jobs and asynchronous tasks in Node.js.

Provides the ability to spawn child processes using `spawn`, `fork`, `exec`, or `execFile`.

`spawn` returns a stream (better for large data). `exec` buffers the entire output in memory (simpler but limited to a few MBs).

A stable API for building native Node.js addons that is independent of the underlying JavaScript engine version.

By adding listeners to the `process` object to log the error and crash/restart gracefully.

A design pattern where an object receives its dependencies from the outside rather than creating them itself, improving testability.

A principle where the control of object creation and lifecycle is shifted from the programmer to a framework/container.

Using `express-rate-limit` or a custom Redis-based store to track and limit requests per IP.

The practice of periodically archiving and deleting old log files to prevent them from consuming too much disk space.

Powerful logging libraries for Node.js that support different log levels and transports (file, console, external services).

Using tools like `knex` or `sequelize-cli` to track and apply changes to the database schema over time.

A design pattern used to prevent an application from repeatedly trying to execute an operation that's likely to fail (e.g., calling a down service).

Ignition (interpreter) generates bytecode -> TurboFan (compiler) optimizes hot code to machine code -> Orinoco (GC) reclaims memory.

An optimization technique where V8 creates internal classes for objects with the same structure to allow fast property access.

V8 replaces a function call with the actual body of the function to reduce call overhead if the function is small and frequently called.

`alloc` zeroes the memory (safe). `allocUnsafe` does not zero memory (faster but may contain old sensitive data).

A technique to avoid unnecessary data copying between the kernel and application memory, often used in networking and file transfers.

A file representing the memory distribution of a Node.js process at a specific point in time, used for memory leak analysis.

A visualization tool used to analyze CPU profile data and find performance bottlenecks in your code.

Defaults to 4. Can be increased via `UV_THREADPOOL_SIZE` for handling more simultaneous file/crypto/dns operations.

An Isolate is an independent instance of the V8 engine, including its own heap, garbage collector, etc.

Crankshaft was the old JIT compiler. TurboFan is the modern replacement that handles ES6 features and optimization more effectively.

Using N-API or NaN (Native Abstractions for Node.js) to bridge C++ code and the V8 engine.

Allow multiple threads (Workers) to share the same memory and perform atomic operations to avoid race conditions.

A single iteration of the event loop. The number of ticks per second is a metric of loop latency.

The delay between when an event is scheduled and when it's actually processed. High lag indicates a blocked event loop.

By extending the `Readable`, `Writable`, or `Transform` classes and implementing the `_read`, `_write`, or `_transform` methods.

Newer protocols that reduce latency by using UDP instead of TCP, with built-in encryption and multiplexing.

Using the `BigInt` type (e.g., `100n`) for handling integers larger than `Number.MAX_SAFE_INTEGER`.

Shadow DOM is a browser technology for encapsulation. Virtual DOM is a JavaScript library concept for UI syncing.

Removing unused code from the final bundle during the build step using tools like Webpack or Rollup.

An attack that exploits poorly written Regex that take exponential time to process certain strings, blocking the event loop.

Combining Metrics (Prometheus), Logs (ELK), and Traces (Tempo) to understand the internal state of the system.

Purposely introducing failures (like killing nodes or adding latency) to test the resilience of the system.

Modules are cached after the first time they are loaded. Subsequent requires return the same instance, making them effective singletons.

Occurs when Module A requires Module B, and B requires A. Node.js handles this by returning an incomplete export object from the second require.

Allows you to programmatically interact with the V8 inspector for debugging and profiling.

A way for a browser extension to exchange messages with a native Node.js application installed on the user's machine.

A method of improving performance of interpreted programs by compiling code into machine language at runtime.

Using separate databases per tenant, separate schemas, or a discriminator column in shared tables.

Using 'Transactions' (since Mongo 4.0) to ensure multiple operations either all succeed or all fail.

Using 'Coalescing' (e.g., via `dataloader`) to ensure that multiple identical requests for the same resource only trigger one DB/API call.

A symbolic link to a file or directory. Node.js resolves these differently depending on the `--preserve-symlinks` flag.

Node.js wraps every module in a function: `(function(exports, require, module, __filename, __dirname) { ... })` before executing it.

`exports` is a reference to `module.exports`. If you assign a new value to `exports`, it no longer references `module.exports`, causing no exports.

Using the `zlib` module to compress/decompress buffers and streams using Gzip, Deflate, or Brotli.

V8 lazily parses functions only when they are needed, performing a quick 'pre-parse' first to check for syntax errors.

V8 caches the generated bytecode for scripts to speed up subsequent loads of the same script.

Using libraries like `commander`, `yargs`, or `inquirer` and adding `#!/usr/bin/env node` to the main file.

Used to interact with terminal windows (e.g., checking if the app is running in a terminal via `process.stdout.isTTY`).

Allows compiling and running code within V8 Virtual Machine contexts. Not a security sandbox!

Assigning users to groups based on their ID hash and serving different logic/routes accordingly.

How services find each other's locations (IP/Port) in a dynamic network, using tools like Consul or Kubernetes DNS.

A single entry point for all clients that routes requests to internal microservices, handles auth, and optionally aggregates data.

Deploying a helper service (like a proxy or logger) alongside the main application container.

Following the `MAJOR.MINOR.PATCH` format to communicate breaking changes, features, and bug fixes.

A command that checks for known security vulnerabilities in your project's dependencies.

Dependencies that a package requires the HOST application to provide, common in plugin development.

Passing the same `signal` to multiple fetch/timer calls so they all cancel when the `controller.abort()` is called.

Support for using `await` at the top level of ES modules without being inside an `async` function.

Loading and running high-performance binary code (compiled from C++/Rust) inside the Node.js runtime.

Obfuscating sensitive information (like Credit Card numbers) before logging or displaying it to unauthorized users.

Use fs.readFile or streams.

const fs = require('fs');
fs.readFile('test.txt', 'utf8', (err, data) => {
  const words = data.split(/\s+/).length;
  console.log(words);
});

Use the http module.

const http = require('http');
http.createServer((req, res) => {
  res.writeHead(200);
  res.end('Hello Node!');
}).listen(3000);

Use fs.readdir.

const fs = require('fs');
fs.readdir('./', (err, files) => {
  console.log(files);
});

Manual promise or util.promisify.

const fs = require('fs').promises;
async function read() {
  const data = await fs.readFile('f.txt', 'utf8');
  return data;
}

Create a custom class extender.

const EventEmitter = require('events');
const myEmitter = new EventEmitter();
myEmitter.on('test', () => console.log('OK'));
myEmitter.emit('test');

Accumulate chunks of data.

let body = '';
req.on('data', chunk => body += chunk);
req.on('end', () => {
  const data = JSON.parse(body);
});

Check headers for auth token.

const auth = (req, res, next) => {
  if(req.headers.auth === 'secret') next();
  else res.status(401).send();
};

Use crypto module and streams.

const crypto = require('crypto');
const hash = crypto.createHash('sha256');
stream.on('data', data => hash.update(data));

Create readable stream and pipe to res.

fs.createReadStream('file.pdf').pipe(res);

Spread operator or Object.assign.

const merged = { ...obj1, ...obj2 };

Use fs.stat and .isDirectory().

fs.stat('path', (err, stats) => {
  console.log(stats.isDirectory());
});

Use Promise.all().

await Promise.all([task1(), task2()]);

Return a promise that resolves after N ms.

const delay = ms => new Promise(res => setTimeout(res, ms));

Use Set.

const unique = [...new Set(arr)];

Use os module.

const os = require('os');
console.log(os.platform(), os.cpus().length);

Pipe read stream -> createGzip -> write stream.

fs.createReadStream('file.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('file.txt.gz'));

process listener.

process.on('unhandledRejection', (err) => {
  console.error(err);
});

Check cluster.isMaster and fork.

if (cluster.isPrimary) cluster.fork();
else http.createServer(...).listen(80);

Array.filter.

const users = list.filter(u => u.age > 18);

Intl.NumberFormat.

new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(100);

Use crypto.randomBytes.

crypto.randomBytes(32).toString('hex');

Array.isArray().

Array.isArray(myVar);

Use a Map to track usage order.

cache.delete(key); cache.set(key, value);

AbortController with setTimeout.

setTimeout(() => controller.abort(), 5000);

Buffer.from().toString('base64').

Buffer.from('hello').toString('base64');

Reduce into an object.

arr.reduce((acc, obj) => {
  (acc[obj.key] = acc[obj.key] || []).push(obj);
  return acc;
}, {});

child_process.exec.

exec('ls', (err, stdout) => console.log(stdout));

Try-catch JSON.parse.

try { JSON.parse(str); return true; } catch { return false; }

Implement _write method.

class MyW extends Writable {
  _write(chunk, enc, next) { ... next(); }
}

Filter and Includes.

arr1.filter(x => arr2.includes(x));

Continuously add items to a global array.

setInterval(() => leaks.push(new Array(100000)), 100);

Timeout closure.

return (...args) => {
  clearTimeout(t);
  t = setTimeout(() => f(...args), ms);
};

Flag based execution.

if(!wait) { f(); wait = true; setTimeout(()=>wait=false, ms); }

Native modern JS method.

const copy = structuredClone(original);

Push to S1, Pop from S2 (filling from S1 when empty).

enqueue(x) { s1.push(x) }

Standard math loop.

for(let i=2; i < n; i++) if(n%i===0) return false;

Split, reverse, join.

s.split(' ').reverse().join(' ');

Sort and pick middle.

const s = arr.sort((a,b)=>a-b); return s[len/2];

new Date(ms).

new Date(1600000000 * 1000).toLocaleString();

Loop with try-catch and delay.

for(let i=0; i<3; i++) try { return fetch(); } catch { await delay(); }

Recursive key concatenation.

const flat = (o, p) => ... o[p + key] = val;

Use url module or URL class.

const params = new URL(req.url, 'http://x').searchParams;

Slice and toUpperCase.

s[0].toUpperCase() + s.slice(1);

Reduce into object.

s.split('').reduce((a,c) => { a[c] = (a[c]||0)+1; return a; }, {});

Pipe read to write stream.

fs.createReadStream('a').pipe(fs.createWriteStream('b'));

Frequency count and find index.

const char = s.split('').find(c => s.indexOf(c) === s.lastIndexOf(c));

Midpoint comparison in sorted array.

while(l <= r) { m = (l+r)/2; if(arr[m] === t) ... }

Spawn worker and listen for message.

const worker = new Worker('./math.js'); worker.postMessage(n);

Regex replace with object keys.

s.replace(/{{(\w+)}}/g, (m, k) => obj[k]);

Sort and compare.

sort(s1) === sort(s2);