The Ultimate Node.js Cheatsheet

// ── ES Modules (recommended) ──
// package.json: { "type": "module" }

import fs from 'node:fs/promises';
import path from 'node:path';
import http from 'node:http';
import { fileURLToPath } from 'node:url';

export function greet(name) {
  return `Hello, ${name}!`;
}

export default function main() {
  console.log('Main function');
}

// ── CommonJS (legacy) ──
const fs = require('fs');
const path = require('path');
module.exports = { greet, main };

import path from 'node:path';
import { fileURLToPath } from 'node:url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// ── Path Methods ──
path.join('/foo', 'bar', 'baz/asdf', 'quux');   // '/foo/bar/baz/asdf/quux'
path.resolve('foo/bar', '/tmp/file/', '..', 'a'); // '/tmp/a'
path.normalize('/foo/bar//baz/asdf/quux/..');     // '/foo/bar/baz/asdf'
path.dirname('/foo/bar/baz.txt');                  // '/foo/bar'
path.basename('/foo/bar/baz.txt');                 // 'baz.txt'
path.basename('/foo/bar/baz.txt', '.txt');         // 'baz'
path.extname('/foo/bar/baz.txt');                  // '.txt'
path.parse('/home/user/dir/file.txt');
// { root: '/', dir: '/home/user/dir', base: 'file.txt', ext: '.txt', name: 'file' }
path.format({ root: '/', dir: '/home', base: 'file.txt' }); // '/home/file.txt'
path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb'); // '../../impl/bbb'
path.isAbsolute('/foo/bar');   // true
path.isAbsolute('./quux');     // false

import url from 'node:url';

const myURL = new URL('https://user:pass@example.com:8080/p/a/t/h?query=string#hash');
myURL.href;        // 'https://user:pass@example.com:8080/p/a/t/h?query=string#hash'
myURL.origin;      // 'https://example.com:8080'
myURL.protocol;    // 'https:'
myURL.username;    // 'user'
myURL.password;    // 'pass'
myURL.hostname;    // 'example.com'
myURL.port;        // '8080'
myURL.pathname;    // '/p/a/t/h'
myURL.search;      // '?query=string'
myURL.hash;        // '#hash'
myURL.searchParams.get('query'); // 'string'
myURL.searchParams.append('page', '1');
myURL.searchParams.toString();   // 'query=string&page=1'

import { Buffer } from 'node:buffer';

// ── Creating Buffers ──
const buf1 = Buffer.from('hello');           // <Buffer 68 65 6c 6c 6f>
const buf2 = Buffer.alloc(10);              // 10 zero-filled bytes
const buf3 = Buffer.allocUnsafe(10);        // 10 uninitialized bytes (faster)
const buf4 = Buffer.from([1, 2, 3, 4]);    // from byte array
const buf5 = Buffer.from('7468697320697320612074', 'hex'); // from hex

// ── Buffer Operations ──
buf1.toString();          // 'hello'
buf1.toString('hex');     // '68656c6c6f'
buf1.toString('base64');  // 'aGVsbG8='
buf1.length;              // 5
buf1[0];                  // 104 (UTF-8 code for 'h')

Buffer.concat([buf1, Buffer.from(' world')]).toString(); // 'hello world'
Buffer.isBuffer(buf1);    // true
Buffer.byteLength('hello'); // 5
Buffer.from('hello').equals(Buffer.from('hello')); // true

import fs from 'node:fs/promises';
import path from 'node:path';

// ── Reading Files ──
const data = await fs.readFile('file.txt', 'utf-8');
const buffer = await fs.readFile('image.png');  // Buffer for binary

// ── Writing Files ──
await fs.writeFile('file.txt', 'Hello World', 'utf-8');
await fs.appendFile('file.txt', '\nAppended line');

// ── Directories ──
await fs.mkdir('dir/subdir', { recursive: true });
const files = await fs.readdir('dir');
const filesDetailed = await fs.readdir('dir', { withFileTypes: true });
// [Dir, File, Dir, ...] — filter with entry.isDirectory()

await fs.rmdir('dir', { recursive: true }); // remove empty dir
await fs.rm('dir', { recursive: true, force: true }); // remove non-empty

// ── File Info ──
const stats = await fs.stat('file.txt');
stats.isFile();       // true
stats.isDirectory();  // false
stats.size;           // 1234 bytes
stats.mtime;          // Modified timestamp
stats.birthtime;      // Created timestamp

// ── Copy & Rename ──
await fs.copyFile('source.txt', 'dest.txt');
await fs.rename('old.txt', 'new.txt');

import { createReadStream, createWriteStream } from 'node:fs';
import { pipeline } from 'node:stream/promises';
import { createGzip } from 'node:zlib';

// ── Readable Stream (for large files) ──
const readStream = createReadStream('large-file.txt', {
  highWaterMark: 64 * 1024, // 64KB chunks
  encoding: 'utf-8',
});

readStream.on('data', (chunk) => {
  console.log('Chunk:', chunk.length);
});

// ── Writable Stream ──
const writeStream = createWriteStream('output.txt');

// ── Pipe Streams ──
await pipeline(
  createReadStream('input.txt'),
  createGzip(),
  createWriteStream('output.txt.gz'),
);

// ── Process line by line ──
import { readlines } from 'node:fs';
for await (const line of readlines('file.txt')) {
  console.log(line);
}

import { watch } from 'node:fs';

// ── Watch for File Changes ──
const watcher = watch('./src', { recursive: true }, (eventType, filename) => {
  console.log(`${eventType}: ${filename}`);
  // eventType: 'change' or 'rename'
});

// Stop watching
watcher.close();

// ── fs.promises.watch (async iterator) ──
import { watch as asyncWatch } from 'node:fs/promises';

for await (const { eventType, filename } of asyncWatch('./src')) {
  console.log(`${eventType}: ${filename}`);
}

import http from 'node:http';

const server = http.createServer((req, res) => {
  console.log(`${req.method} ${req.url}`);

  // Route handling
  if (req.method === 'GET' && req.url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Hello World');
  } else if (req.method === 'GET' && req.url === '/api/users') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify([{ id: 1, name: 'Alice' }]));
  } else if (req.method === 'POST' && req.url === '/api/users') {
    let body = '';
    req.on('data', (chunk) => { body += chunk; });
    req.on('end', () => {
      const data = JSON.parse(body);
      res.writeHead(201, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ id: 2, ...data }));
    });
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Not Found');
  }
});

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

import http from 'node:http';

// ── HTTP Request ──
const postData = JSON.stringify({ title: 'Hello', body: 'World' });

const options = {
  hostname: 'jsonplaceholder.typicode.com',
  port: 443,
  path: '/posts',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(postData),
  },
};

const req = http.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => {
    console.log('Status:', res.statusCode);
    console.log('Body:', data);
  });
});

req.on('error', (err) => console.error('Error:', err));
req.write(postData);
req.end();

// ── Fetch API (built-in, Node 18+) ──
const response = await fetch('https://api.example.com/data', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ key: 'value' }),
});
const json = await response.json();
console.log(json);

import https from 'node:https';
import fs from 'node:fs';

// ── HTTPS Server ──
const options = {
  key: fs.readFileSync('./certs/key.pem'),
  cert: fs.readFileSync('./certs/cert.pem'),
};

const server = https.createServer(options, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Secure Hello World');
});

server.listen(443, () => {
  console.log('HTTPS server running on port 443');
});

import { EventEmitter } from 'node:events';

// ── Custom EventEmitter ──
class TaskManager extends EventEmitter {
  constructor() {
    super();
  }

  async runTask(taskId) {
    this.emit('start', { taskId, timestamp: Date.now() });
    try {
      const result = await this.execute(taskId);
      this.emit('complete', { taskId, result });
    } catch (error) {
      this.emit('error', { taskId, error });
    }
  }

  async execute(taskId) {
    // simulate async work
    return { status: 'done' };
  }
}

const manager = new TaskManager();

manager.on('start', (data) => console.log(`Task ${data.taskId} started`));
manager.on('complete', (data) => console.log(`Task ${data.taskId} done`));
manager.on('error', (data) => console.error(`Task ${data.taskId} failed:`, data.error));
manager.once('start', () => console.log('First task started!')); // fires once only

// Remove listener
const handler = (data) => console.log(data);
manager.on('complete', handler);
manager.off('complete', handler);

// Get listener count
console.log(manager.listenerCount('complete'));

// List all events
console.log(manager.eventNames());

manager.runTask('task-001');

import { Readable, Writable, Transform } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import { createReadStream, createWriteStream } from 'node:fs';
import { createGzip, createGunzip } from 'node:zlib';
import { pipeline as streamPipeline } from 'node:stream';

// ── Readable Stream (custom) ──
class NumberStream extends Readable {
  constructor(max = 10) {
    super();
    this.current = 1;
    this.max = max;
  }

  _read() {
    if (this.current > this.max) {
      this.push(null); // signal end
    } else {
      this.push(String(this.current++) + '\n');
    }
  }
}

// ── Transform Stream ──
class UpperCaseTransform extends Transform {
  _transform(chunk, encoding, callback) {
    callback(null, chunk.toString().toUpperCase());
  }
}

// ── Writable Stream (custom) ──
class LogWriter extends Writable {
  _write(chunk, encoding, callback) {
    console.log('LOG:', chunk.toString().trim());
    callback();
  }
}

// ── Pipeline (error handling + cleanup) ──
await pipeline(
  new NumberStream(5),
  new UpperCaseTransform(),
  new LogWriter(),
);

// ── File Stream Pipeline ──
await pipeline(
  createReadStream('access.log'),
  createGzip(),
  createWriteStream('access.log.gz'),
);

// ── Process CSV line by line ──
import { createInterface } from 'node:readline';

const rl = createInterface({
  input: createReadStream('data.csv'),
  crlfDelay: Infinity,
});

for await (const line of rl) {
  const [name, age, city] = line.split(',');
  console.log(`${name} is ${age} years old`);
}

// ── Promises ──
const promise = new Promise((resolve, reject) => {
  setTimeout(() => resolve('Done!'), 1000);
});
const result = await promise; // 'Done!'

// ── Promise combinators ──
const [r1, r2, r3] = await Promise.all([p1, p2, p3]); // Wait for ALL
const first = await Promise.any([p1, p2, p3]);        // First to RESOLVE
const allSettled = await Promise.allSettled([p1, p2]); // Wait for ALL (no reject)
const raced = await Promise.race([p1, p2]);             // First to settle

// ── allSettled result format ──
// [
//   { status: 'fulfilled', value: 42 },
//   { status: 'rejected', reason: Error }
// ]

// ── Async/Await Error Handling ──
try {
  const data = await fetchData();
} catch (error) {
  console.error('Failed:', error.message);
} finally {
  console.log('Always runs');
}

// ── Timeout wrapper ──
function withTimeout(promise, ms) {
  const timeout = new Promise((_, reject) =>
    setTimeout(() => reject(new Error('Timeout after ' + ms + 'ms')), ms)
  );
  return Promise.race([promise, timeout]);
}

// Usage
const data = await withTimeout(fetch('/api/data'), 5000);

// ── Retry with exponential backoff ──
async function retry(fn, retries = 3, delay = 1000) {
  for (let i = 0; i <= retries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (i === retries) throw error;
      const wait = delay * Math.pow(2, i);
      console.log(`Retry ${i + 1}/${retries} in ${wait}ms`);
      await new Promise(r => setTimeout(r, wait));
    }
  }
}

// Usage
const data = await retry(() => fetch('/api/data').then(r => r.json()));

// ── Async queue (concurrency limit) ──
async function asyncQueue(tasks, concurrency = 3) {
  const results = [];
  let index = 0;

  async function worker() {
    while (index < tasks.length) {
      const currentIndex = index++;
      results[currentIndex] = await tasks[currentIndex]();
    }
  }

  const workers = Array.from(
    { length: Math.min(concurrency, tasks.length) },
    () => worker()
  );
  await Promise.all(workers);
  return results;
}

import { exec, spawn, fork } from 'node:child_process';
import { promisify } from 'node:util';

const execAsync = promisify(exec);

// ── exec: run command, get output ──
const { stdout, stderr } = await execAsync('ls -la');
console.log(stdout);

// ── spawn: streaming output (for long processes) ──
const child = spawn('find', ['.', '-name', '*.js']);

child.stdout.on('data', (data) => process.stdout.write(data));
child.stderr.on('data', (data) => process.stderr.write(data));
child.on('close', (code) => console.log('Exit code:', code));

// ── fork: run Node.js module in child process ──
const worker = fork('./worker.js');
worker.send({ task: 'compute', data: [1, 2, 3] });
worker.on('message', (result) => console.log('Result:', result));
worker.on('exit', (code) => console.log('Worker exited:', code));

// ── Worker Threads (CPU-intensive tasks) ──
import { Worker } from 'node:worker_threads';

function runInWorker(filename, data) {
  return new Promise((resolve, reject) => {
    const worker = new Worker(filename, { workerData: data });
    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => {
      if (code !== 0) reject(new Error('Worker stopped with code ' + code));
    });
  });
}

// Usage: const result = await runInWorker('./heavy-task.js', { limit: 1000000 });

{
  "name": "my-app",
  "version": "1.0.0",
  "type": "module",
  "description": "A Node.js application",
  "main": "src/index.js",
  "bin": {
    "my-cli": "./bin/cli.js"
  },
  "scripts": {
    "dev": "node --watch src/index.js",
    "start": "node src/index.js",
    "build": "tsc",
    "test": "vitest",
    "lint": "eslint src/",
    "prepare": "husky"
  },
  "engines": {
    "node": ">=20.0.0"
  },
  "dependencies": {
    "express": "^4.21.0"
  },
  "devDependencies": {
    "typescript": "^5.6.0",
    "eslint": "^9.0.0"
  }
}

# ── npm (Node Package Manager) ──
npm init -y                   # Create package.json
npm install express           # Add dependency
npm install -D typescript     # Add dev dependency
npm install -g pm2            # Global install

npm uninstall express         # Remove dependency
npm update                    # Update all packages
npm outdated                  # Check for updates

npm run dev                   # Run script
npm run build -- --production # Pass args to script

npm ls                        # List installed packages
npm ls --depth=0              # Top-level only
npm root                      # Show node_modules path

npm pack                      # Create tarball
npm publish                   # Publish to registry

# ── npx: run packages without installing ──
npx create-next-app@latest my-app
npx prisma generate
npx tsx src/index.ts

# ── npm scripts lifecycle ──
# preinstall → install → postinstall
# prestart → start → poststart
# pretest → test → posttest

# ── pnpm (fast, disk-efficient) ──
pnpm install                  # Install all deps
pnpm add express              # Add dependency
pnpm add -D typescript        # Add dev dependency
pnpm remove express           # Remove dependency

pnpm add lodash@4.17.21       # Install specific version
pnpm add "express@^4.18.0"    # Install with range

pnpm run dev                  # Run script
pnpm dlx create-next-app      # Like npx but faster

# ── Workspace (monorepo) ──
# pnpm-workspace.yaml
# packages:
#   - 'apps/*'
#   - 'packages/*'

pnpm --filter @app/web dev    # Run in specific package
pnpm --filter @app/web build  # Build specific package
pnpm -r run build             # Run in all packages recursively
pnpm -r exec "tsc --noEmit"   # Execute command in all packages

import { performance, PerformanceObserver } from 'node:perf_hooks';

// ── Measuring Execution Time ──
const start = performance.now();
await expensiveOperation();
const end = performance.now();
console.log(`Took ${(end - start).toFixed(2)}ms`);

// ── Performance Observer ──
const obs = new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    console.log(`${entry.name}: ${entry.duration}ms`);
  }
});
obs.observe({ entryTypes: ['function', 'measure'] });

// ── process.memoryUsage() ──
const memory = process.memoryUsage();
console.log({
  rss: Math.round(memory.rss / 1024 / 1024) + 'MB',        // Total memory
  heapTotal: Math.round(memory.heapTotal / 1024 / 1024) + 'MB',  // Heap allocated
  heapUsed: Math.round(memory.heapUsed / 1024 / 1024) + 'MB',    // Heap used
  external: Math.round(memory.external / 1024 / 1024) + 'MB',    // C++ objects
});

// ── Cluster (multi-process) ──
import cluster from 'node:cluster';
import os from 'node:os';

if (cluster.isPrimary) {
  const cpus = os.cpus().length;
  console.log(`Primary ${process.pid} is running`);
  for (let i = 0; i < cpus; i++) {
    cluster.fork();
  }
  cluster.on('exit', (worker) => {
    console.log(`Worker ${worker.process.pid} died. Restarting...`);
    cluster.fork(); // Auto-restart
  });
} else {
  // Worker: start HTTP server
  import('./server.js');
}

// ── Node.js Inspector (built-in debugger) ──
// Start with: node --inspect server.js
// Open: chrome://inspect in Chrome

// ── Debug with breakpoints in code ──
debugger; // Pauses execution when inspector is attached

// ── Worker Inspector ──
// node --inspect=9229 --inspect-brk server.js
// --inspect-brk: break on first line

// ── Environment Variables for Debugging ──
NODE_DEBUG=http           // Debug HTTP module
NODE_DEBUG=net,fs         // Debug multiple modules
NODE_OPTIONS="--inspect"  // Enable inspector via env

// ── process object utilities ──
process.env.NODE_ENV;           // 'production' | 'development'
process.argv;                   // [node, script.js, ...args]
process.pid;                    // Process ID
process.ppid;                   // Parent process ID
process.cwd();                  // Current working directory
process.chdir('/tmp');          // Change directory
process.exit(0);                // Exit with code 0
process.nextTick(() => {});     // Run callback before I/O

// ── Uncaught Exception Handler ──
process.on('uncaughtException', (err) => {
  console.error('Uncaught:', err);
  // Log and gracefully shutdown
  process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled rejection:', reason);
});

// ── Graceful Shutdown ──
const shutdown = (signal) => {
  console.log(`${signal} received. Shutting down gracefully...`);
  server.close(() => {
    console.log('HTTP server closed');
    db.close(() => {
      console.log('DB connection closed');
      process.exit(0);
    });
  });
};

process.on('SIGTERM', () => shutdown('SIGTERM'));
process.on('SIGINT', () => shutdown('SIGINT'));