Node.js Interview Questions

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

JavaScript Code (Your app)
    ↓
Node.js API (Core Modules)
    ↓
Node.js Bindings (C++ layer)
    ↓
V8 Engine  |  Libuv (Event Loop, Thread Pool)
    ↓
Operating System (File System, Network, etc.)

// JavaScript runs on the main thread (single-threaded)
console.log('Main thread:', process.pid);

// Blocking the main thread blocks EVERYTHING
setTimeout(() => console.log('Never runs during blocking'), 0);
while (true) {} // ❌ Blocks event loop

const EventEmitter = require('events');

class Server extends EventEmitter {
  start() {
    console.log('Server started');
    this.emit('ready');
  }
}

const server = new Server();
server.on('ready', () => console.log('Ready to handle requests'));
server.start();

// ❌ Blocking (synchronous) — blocks the thread
const data = fs.readFileSync('file.txt');  // Waits here
console.log('Done reading');

// ✅ Non-blocking (asynchronous) — doesn't block
fs.readFile('file.txt', (err, data) => {
  console.log('Done reading');  // Runs later
});
console.log('This runs first');

// V8 optimizes hot code paths automatically
for (let i = 0; i < 100000; i++) {
  // After ~10,000 iterations, V8 compiles this to optimized machine code
  doSomething(i);
}

// File I/O goes through libuv's thread pool
fs.readFile('/large/file.txt', callback);  // libuv thread pool handles this

// Network I/O goes through OS kernel (epoll/kqueue/IOCP)
http.get('http://example.com', callback);  // OS async I/O, no thread pool

   ┌───────────────────────────┐
┌─>│           timers          │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │     pending callbacks     │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │       idle, prepare       │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │           poll            │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │           check           │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
└──┤      close callbacks      │
   └───────────────────────────┘

// Node.js: process is the global process object
console.log(process.version);  // "v20.x.x"

// Browser: window is the global object
console.log(window.innerWidth);  // Viewport width

{
  "name": "my-app",
  "version": "1.0.0",
  "description": "My Node.js application",
  "main": "index.js",
  "type": "module",          // "module" for ESM, "commonjs" for CJS
  "scripts": {
    "start": "node index.js",
    "dev": "node --watch index.js",
    "test": "jest"
  },
  "dependencies": {
    "express": "^4.18.0"     // Caret: minor version updates allowed
  },
  "devDependencies": {
    "jest": "^29.0.0"        // Dev only (testing)
  },
  "engines": {
    "node": ">=20.0.0"       // Node.js version requirement
  }
}

{
  "name": "my-app",
  "lockfileVersion": 3,    // npm v7+ format
  "packages": {
    "node_modules/express": {
      "version": "4.18.2",  // Exact version locked
      "resolved": "https://...",
      "integrity": "sha512-..."
    }
  }
}

v2.4.1 → Major: 2, Minor: 4, Patch: 1

project/
├── src/
│   ├── controllers/      # Request handlers
│   ├── models/           # Data models
│   ├── routes/           # Route definitions
│   ├── middleware/       # Express middleware
│   ├── services/         # Business logic
│   ├── utils/            # Utility functions
│   ├── config/           # Configuration
│   └── app.js            # Express app setup
├── tests/                # Test files
├── scripts/              # Build/deploy scripts
├── node_modules/         # Dependencies
├── .env                  # Environment variables
├── .env.example          # Environment template
├── .gitignore
├── package.json
├── package-lock.json
├── README.md
└── Dockerfile

// Access environment variables
const port = process.env.PORT || 3000;
const dbUrl = process.env.DATABASE_URL;
const nodeEnv = process.env.NODE_ENV || 'development';

// With dotenv package (.env file)
// .env file:
// PORT=4000
// DATABASE_URL=postgres://localhost:5432/mydb

import 'dotenv/config';
// Or: require('dotenv').config();

// Set in terminal
// PORT=4000 node index.js
// Or: export PORT=4000 (Unix)
// Or: set PORT=4000 (Windows cmd)

// CommonJS
const express = require('express');
module.exports = { myFunction };

// ES Modules
import express from 'express';
export const myFunction = () => {};
export default myFunction;

// Loading order
require('fs');              // 1. Core module
require('./utils/helper');  // 2. Relative path (resolves .js, .json, .node)
require('express');         // 3. node_modules/express
require('example');         // 4. Searches parent directories' node_modules

// These are equivalent:
module.exports.foo = 'bar';
exports.foo = 'bar';  // ✓ Works (exports references module.exports)

// ❌ THIS BREKS IT:
exports = { foo: 'bar' };  // Reassigns exports, NOT module.exports!
// require() still returns module.exports (empty object!)

// ✅ Correct way to export a single value:
module.exports = { foo: 'bar' };

// Pattern:
// Adding properties to exports → works
// Reassigning exports → breaks the reference
// Always use module.exports for clarity

// Dynamic import — returns a Promise
async function loadModule(name) {
  try {
    const module = await import(`./plugins/${name}.js`);
    return module.default;
  } catch (err) {
    console.error(`Failed to load plugin: ${name}`, err);
  }
}

// Conditional loading
if (process.env.FEATURE_FLAG) {
  const { feature } = await import('./feature.js');
  feature.init();
}

// Type-based loading
const format = file.endsWith('.json') ? 'json' : 'yaml';
const parser = await import(`./parsers/${format}.js`);

// Dynamic import in CommonJS
async function loadExpress() {
  const express = await import('express');
  // Not cached like require — each call re-evaluates!
}

1. Check if it's a BUILT-IN module (fs, path, http, etc.)
   → Yes: Return the core module

2. Check if path starts with '/' (absolute) or './' / '../' (relative)
   → Yes: Resolve relative to the current file
     - Try exact filename
     - Try + .js, .json, .node, .mjs, .cjs
     - Try/index.js, index.json, index.node
     - Fail: MODULE_NOT_FOUND

3. Look in node_modules/
   → Walk UP the directory tree checking node_modules/ at each level
   → Same resolution steps as #2

4. MODULE_NOT_FOUND error

// Resolution order example for require('./data')
// 1. ./data.js
// 2. ./data.json
// 3. ./data.node
// 4. ./data/index.js
// 5. ./data/index.json
// 6. ./data/index.node
// 7. MODULE_NOT_FOUND

const fs = require('fs');           // File system operations
const path = require('path');       // File path utilities
const http = require('http');       // HTTP server/client
const https = require('https');     // HTTPS server/client
const os = require('os');           // Operating system info
const crypto = require('crypto');   // Cryptographic functions
const events = require('events');   // Event emitter
const stream = require('stream');   // Streaming data
const buffer = require('buffer');   // Binary data handling
const util = require('util');       // Utility functions
const child_process = require('child_process'); // Spawn processes
const cluster = require('cluster'); // Multi-process scaling
const worker_threads = require('worker_threads'); // Threads
const net = require('net');         // TCP server/client
const dns = require('dns');         // DNS resolution
const url = require('url');         // URL parsing
const readline = require('readline'); // Readable input
const zlib = require('zlib');       // Compression
const timers = require('timers');   // setTimeout/setInterval

const fs = require('fs');

// Reading
fs.readFile('file.txt', 'utf8', (err, data) => console.log(data));
const data = fs.readFileSync('file.txt', 'utf8');

// Writing
fs.writeFile('file.txt', 'Hello', (err) => {});
fs.writeFileSync('file.txt', 'Hello');

// Appending
fs.appendFile('file.txt', 'More text', () => {});

// Directory operations
fs.mkdir('new-dir', { recursive: true }, () => {});
fs.readdir('./', (err, files) => console.log(files));

// File info
const stats = fs.statSync('file.txt');
stats.isFile();      // true
stats.isDirectory(); // false
stats.size;          // File size in bytes

// Watch for changes
fs.watch('file.txt', (event, filename) => {
  console.log(`${filename} changed: ${event}`);
});

// Promises API (Node.js v14+)
const fsp = require('fs/promises');
const data = await fsp.readFile('file.txt', 'utf8');

const path = require('path');

// Join path segments
path.join('/users', 'john', 'documents', 'file.txt');
// '/users/john/documents/file.txt' (uses OS separator)

// Resolve to absolute path
path.resolve('file.txt');            // '/current/dir/file.txt'
path.resolve('/base', 'file.txt');   // '/base/file.txt'

// Get directory name
path.dirname('/a/b/c.txt');  // '/a/b'

// Get file name
path.basename('/a/b/c.txt');       // 'c.txt'
path.basename('/a/b/c.txt', '.txt'); // 'c'

// Get extension
path.extname('/a/b/c.txt');  // '.txt'

// Parse path
path.parse('/home/user/file.txt');
// { root: '/', dir: '/home/user', base: 'file.txt', ext: '.txt', name: 'file' }

// Normalize
path.normalize('/a/b//c/../d');  // '/a/b/d'

// Platform-specific separator
path.sep;   // '/' on Unix, '\\' on Windows

const os = require('os');

// System info
os.platform();       // 'linux', 'darwin', 'win32'
os.arch();           // 'x64', 'arm64'
os.release();        // '5.15.0-...' (kernel version)
os.hostname();       // Machine hostname
os.type();           // 'Linux', 'Darwin', 'Windows_NT'

// CPU info
os.cpus();           // Array of CPU/core objects
os.cpus().length;    // Number of CPU cores

// Memory
os.totalmem();       // Total memory in bytes
os.freemem();        // Free memory in bytes

// Network
os.networkInterfaces(); // Network interfaces

// User info
os.homedir();        // User home directory
os.userInfo();       // User info object
os.tmpdir();         // Temp directory

// Uptime
os.uptime();         // System uptime in seconds

// Memory usage in MB
const used = (os.totalmem() - os.freemem()) / 1024 / 1024;
console.log(`Memory usage: ${used.toFixed(2)} MB`);

// Process info
process.pid;            // Process ID
process.ppid;           // Parent process ID
process.title;          // Process title
process.platform;       // 'linux', 'darwin', 'win32'
process.arch;           // 'x64', 'arm64'
process.version;        // Node.js version (v20.x.x)
process.versions;       // All version info (v8, libuv, etc.)
process.release;        // Release info

// Environment
process.env;            // Environment variables
process.env.NODE_ENV;   // 'development', 'production'
process.argv;           // Command line arguments

// Current working directory
process.cwd();          // Current directory
process.chdir('/tmp');  // Change directory

// Exit
process.exit(0);        // Exit with success
process.exitCode = 1;   // Set exit code (graceful)

// Events
process.on('exit', (code) => console.log(`Exiting with ${code}`));
process.on('uncaughtException', (err) => console.error(err));
process.on('unhandledRejection', (reason) => console.error(reason));

// Memory
process.memoryUsage();
// { rss, heapTotal, heapUsed, external }

// Next tick (microtask)
process.nextTick(() => console.log('Runs before next event loop phase'));

const http = require('http');

const server = http.createServer((req, res) => {
  // Set response header
  res.writeHead(200, { 'Content-Type': 'application/json' });

  // Route handling
  if (req.url === '/') {
    res.end(JSON.stringify({ message: 'Hello World' }));
  } else if (req.url === '/api/users') {
    res.end(JSON.stringify([{ id: 1, name: 'Alice' }]));
  } else {
    res.writeHead(404);
    res.end(JSON.stringify({ error: 'Not Found' }));
  }
});

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

import http from 'http';

const server = http.createServer((req, res) => {
  res.end('Hello');
});

await new Promise(resolve => server.listen(3000, resolve));
console.log('Server running');

const server = http.createServer((req, res) => {
  req.method;        // 'GET', 'POST', etc.
  req.url;           // '/api/users?id=123'
  req.headers;       // { 'content-type': 'application/json', ... }
  req.httpVersion;   // '1.1'
  req.statusCode;    // Only for client requests

  // Read body
  let body = '';
  req.on('data', chunk => body += chunk);
  req.on('end', () => console.log('Body:', body));
});

res.writeHead(200, { 'Content-Type': 'text/plain' });
res.setHeader('X-Custom', 'value');
res.statusCode = 404;
res.write('Partial response');
res.end('Final response');  // Must call end()

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

// Middleware
app.use(express.json());

// Routes
app.get('/', (req, res) => res.send('Hello World'));
app.get('/users/:id', (req, res) => {
  res.json({ id: req.params.id });
});

// Error handling
app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json({ error: 'Internal server error' });
});

app.listen(3000);

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

// Route methods
app.get('/users', listUsers);
app.post('/users', createUser);
app.put('/users/:id', updateUser);
app.delete('/users/:id', deleteUser);
app.patch('/users/:id', partialUpdate);

// Route parameters
app.get('/users/:userId/posts/:postId', (req, res) => {
  const { userId, postId } = req.params;
  res.json({ userId, postId });
});

// Query parameters
app.get('/search', (req, res) => {
  const { q, page = 1 } = req.query;
  res.json({ query: q, page });
});

// Multiple handlers (middleware chain)
app.get('/protected', authenticate, authorize, handler);

// Router
const router = express.Router();
router.get('/profile', getProfile);
app.use('/api', router);

// Chained routes
app.route('/users/:id')
  .get(getUser)
  .put(updateUser)
  .delete(deleteUser);

// Application-level middleware
app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next();  // Pass to next middleware
});

// Built-in middleware
app.use(express.json());         // Parse JSON bodies
app.use(express.urlencoded({ extended: true }));  // Parse URL-encoded bodies
app.use(express.static('public'));  // Serve static files

// Third-party middleware
const helmet = require('helmet');
const cors = require('cors');
app.use(helmet());               // Security headers
app.use(cors());                 // CORS

// Error-handling middleware (4 parameters!)
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Something broke!' });
});

// Async error wrapper
const asyncHandler = (fn) => (req, res, next) =>
  Promise.resolve(fn(req, res, next)).catch(next);

// Routes that throw errors
app.get('/users/:id', asyncHandler(async (req, res) => {
  const user = await findUser(req.params.id);
  if (!user) {
    const err = new Error('User not found');
    err.status = 404;
    throw err;
  }
  res.json(user);
}));

// Global error middleware (must be after routes)
app.use((err, req, res, next) => {
  const status = err.status || 500;
  const message = err.message || 'Internal Server Error';

  console.error(`[${status}] ${message}`);
  if (status === 500) console.error(err.stack);

  res.status(status).json({
    error: message,
    ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
  });
});

// RESTful API design
GET    /users          // List users
POST   /users          // Create user
GET    /users/:id      // Get single user
PUT    /users/:id      // Full update
PATCH  /users/:id      // Partial update
DELETE /users/:id      // Delete user
GET    /users/:id/posts // User's posts

// Query parameters for filtering, sorting, pagination
GET /users?role=admin&page=1&limit=20&sort=name

eyJhbGciOiJIUzI1NiJ9.eyJ1c2VySWQiOjF9.abc123signature

const jwt = require('jsonwebtoken');

// Login: create token
app.post('/login', async (req, res) => {
  const user = await authenticate(req.body);
  const token = jwt.sign(
    { userId: user.id, role: user.role },
    process.env.JWT_SECRET,
    { expiresIn: '1h' }
  );
  res.json({ token });
});

// Middleware: verify token
function authenticate(req, res, next) {
  const header = req.headers.authorization;
  if (!header?.startsWith('Bearer ')) {
    return res.status(401).json({ error: 'No token provided' });
  }
  try {
    const decoded = jwt.verify(header.split(' ')[1], process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (err) {
    res.status(401).json({ error: 'Invalid token' });
  }
}

// Protected route
app.get('/profile', authenticate, (req, res) => {
  res.json({ userId: req.user.userId });
});

const bcrypt = require('bcrypt');

// Hash password (async)
const saltRounds = 12;  // Higher = more secure but slower
const hashedPassword = await bcrypt.hash('userPassword', saltRounds);

// Compare password
const isMatch = await bcrypt.compare('userPassword', hashedPassword);

const cors = require('cors');

// Allow all origins (development only)
app.use(cors());

// Specific origin
app.use(cors({
  origin: 'https://myapp.com',
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  credentials: true,  // Allow cookies
  maxAge: 86400        // Cache preflight request for 24h
}));

// Dynamic origin
app.use(cors({
  origin: (origin, callback) => {
    const whitelist = ['https://app1.com', 'https://app2.com'];
    if (!origin || whitelist.includes(origin)) {
      callback(null, true);
    } else {
      callback(new Error('Not allowed by CORS'));
    }
  }
}));

const helmet = require('helmet');
app.use(helmet());

// What Helmet sets:
// Content-Security-Policy — Prevents XSS
// X-Content-Type-Options  — Prevents MIME sniffing
// X-Frame-Options         — Prevents clickjacking
// Strict-Transport-Security — Enforces HTTPS
// X-XSS-Protection        — XSS filter (legacy)
// Referrer-Policy         — Controls referrer header

const mongoose = require('mongoose');
await mongoose.connect(process.env.MONGODB_URI);
const User = mongoose.model('User', { name: String, email: String });

const { Pool } = require('pg');
const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const { rows } = await pool.query('SELECT * FROM users WHERE id = $1', [id]);

const mysql = require('mysql2/promise');
const conn = await mysql.createConnection(process.env.DATABASE_URL);
const [rows] = await conn.execute('SELECT * FROM users WHERE id = ?', [id]);

const Redis = require('ioredis');
const redis = new Redis(process.env.REDIS_URL);
await redis.set('key', 'value');
const value = await redis.get('key');

const multer = require('multer');
const path = require('path');

// Storage configuration
const storage = multer.diskStorage({
  destination: (req, file, cb) => cb(null, 'uploads/'),
  filename: (req, file, cb) => {
    const unique = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, unique + path.extname(file.originalname));
  }
});

// File filter
const fileFilter = (req, file, cb) => {
  const allowed = ['image/jpeg', 'image/png', 'image/gif'];
  if (allowed.includes(file.mimetype)) {
    cb(null, true);
  } else {
    cb(new Error('Only images allowed'), false);
  }
};

const upload = multer({ storage, fileFilter, limits: { fileSize: 5 * 1024 * 1024 } });

// Single file
app.post('/upload', upload.single('avatar'), (req, res) => {
  res.json({ file: req.file });
});

// Multiple files
app.post('/uploads', upload.array('photos', 10), (req, res) => {
  res.json({ files: req.files });
});

const EventEmitter = require('events');

const emitter = new EventEmitter();

// Register listeners
emitter.on('data', (chunk) => console.log('Data:', chunk));
emitter.once('error', (err) => console.error('Error:', err));

// Emit events
emitter.emit('data', 'Hello');
emitter.emit('data', 'World');

// Remove listeners
emitter.off('data', handler);
emitter.removeAllListeners('data');

// Get listeners
emitter.listeners('data');      // Array of listeners
emitter.listenerCount('data');  // Count

// Max listeners warning (default 10)
emitter.setMaxListeners(20);

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

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

// After promisify
const readFile = util.promisify(fs.readFile);
try {
  const data = await readFile('file.txt', 'utf8');
  console.log(data);
} catch (err) {
  console.error(err);
}

// Custom promisify
function myFunction(param, callback) {
  // Must follow error-first callback pattern
  if (param < 0) return callback(new Error('Invalid param'));
  callback(null, param * 2);
}
const myFunctionAsync = util.promisify(myFunction);
const result = await myFunctionAsync(5); // 10

// setTimeout — runs once after delay
const timeout = setTimeout(() => console.log('Delayed'), 1000);
clearTimeout(timeout);  // Cancel

// setInterval — runs repeatedly
const interval = setInterval(() => console.log('Every second'), 1000);
clearInterval(interval);  // Stop

// setImmediate — runs after I/O callbacks (check phase)
setImmediate(() => console.log('After I/O'));

// unref — allows Node to exit if timer is the only thing pending
timeout.unref();  // Won't prevent exit
timeout.ref();    // Re-allow (default)

setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));
// In main module: order depends on event loop phase
// Inside I/O callback: immediate always runs first

// Standard logging
console.log('Info');
console.warn('Warning');      // stderr
console.error('Error');       // stderr with stack
console.debug('Debug');

// Formatting
console.log('%s %d', 'Age:', 30);
console.log({ name: 'Alice' });          // Object
console.table([{ name: 'Alice' }, { name: 'Bob' }]);  // Table

// Timing
console.time('operation');
// ... expensive operation
console.timeEnd('operation');  // "operation: 234ms"

// Counting
console.count('click');  // "click: 1"
console.count('click');  // "click: 2"

// Stack trace
console.trace('Where am I?');

// Assertion
console.assert(1 === 2, 'This is false');  // Throws AssertionError

// Grouping
console.group('Details');
console.log('Nested');
console.groupEnd();

const isProduction = process.env.NODE_ENV === 'production';
const isDevelopment = process.env.NODE_ENV === 'development';
const isTest = process.env.NODE_ENV === 'test';

// Setting it
// Linux/Mac: NODE_ENV=production node index.js
// Windows: SET NODE_ENV=production && node index.js

// In package.json scripts:
"scripts": {
  "dev": "NODE_ENV=development node --watch index.js",
  "start": "NODE_ENV=production node index.js"
}