Node.js 85 🟢 Cheatsheet

CLI & Runtime Flags

Flag	Purpose
node file.js	Run a script
node -e "code"	Evaluate inline code
node --watch file.js	Auto-restart on change
node --env-file=.env app.js	Load env file natively
node --inspect app.js	Start inspector on :9229
node --inspect-brk app.js	Break on first line
node --prof app.js	Generate V8 CPU profile
node --prof-process isolate-*.log	Read the profile
node --trace-opt app.js	Log optimized functions
node --trace-deopt app.js	Log deoptimized functions
node --allow-fs-read=/path	Restrict fs reads
node --allow-fs-write=/path	Restrict fs writes
node --allow-net=host	Restrict network
node --experimental-permission	Enable permission model
node --max-old-space-size=4096	Heap size (MB)
node --version / -v	Print version

npm Commands

Command	Purpose
npm init -y	Create package.json
npm install pkg	Install dependency
npm install -D pkg	Install dev dependency
npm install -g pkg	Global install
npm ci	Clean install from lock file
npm run <script>	Run script
npm update	Update packages
npm outdated	List outdated packages
npm list --depth=0	Top-level deps
npm audit / npm audit fix	Security check
npx pkg	Run without install
npm link	Symlink local package

Built-in Modules

Module	Key Exports
node:fs	readFile, writeFile, readdir, stat
node:fs/promises	Same, promise-based
node:path	join, resolve, basename, dirname, extname
node:http	createServer, request, get
node:https	createServer, request, get
node:url	URL, URLSearchParams, fileURLToPath
node:os	platform, cpus, homedir, tmpdir, EOL
node:crypto	randomUUID, createHash, createHmac, randomBytes
node:events	EventEmitter, once, on
node:stream	Readable, Writable, Transform, pipeline
node:child_process	spawn, exec, execFile, fork
node:worker_threads	Worker, parentPort, MessageChannel
node:util	promisify, parseArgs, inspect, format
node:buffer	Buffer, atob, btoa
node:timers/promises	setTimeout, setInterval, setImmediate
node:assert	strict, equal, deepEqual, throws

Module Systems

Feature	CommonJS	ESM
Import	require('x')	import x from 'x'
Named	const { a } = require('x')	import { a } from 'x'
Export	module.exports = {...}	export {...}
Extension	.js / .cjs	.mjs / type: module
Top-level await	❌	✅
__dirname	✅ built-in	Via import.meta.url
require in file	✅	createRequire
import()	✅ dynamic	✅ dynamic

// __dirname in ESM
import { fileURLToPath } from 'node:url';
import { dirname } from 'node:path';
const __dirname = dirname(fileURLToPath(import.meta.url));

Event Loop Order

nextTick → Promise microtasks → timers → I/O poll → setImmediate → close

Function	Phase	Priority
process.nextTick()	Before loop continues	Highest
Promise.then()	Microtask queue	High
setTimeout(fn, 0)	Timer phase	Medium
setImmediate(fn)	Check phase	Medium
setInterval(fn, ms)	Timer phase	Medium

fs Cheatsheet

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

// Sync (blocking)
fs.readFileSync('f.txt', 'utf8');
fs.writeFileSync('f.txt', 'data');
fs.existsSync('f.txt');

// Callback
fs.readFile('f.txt', 'utf8', (err, data) => {});

// Promise
await fsp.readFile('f.txt', 'utf8');
await fsp.writeFile('f.txt', 'data');
await fsp.readdir('.');
await fsp.mkdir('dir', { recursive: true });
await fsp.rm('dir', { recursive: true, force: true });

HTTP Server

import { createServer } from 'node:http';

createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ ok: true }));
}).listen(3000);

Child Process

Method	Use
spawn(cmd, args)	Streaming, long-running
exec(cmd, cb)	Buffered shell command
execFile(file, args)	Buffered, no shell
execSync(cmd)	Blocking, avoid in servers
fork(module)	Spawn Node.js child with IPC

import { spawn } from 'node:child_process';
spawn('ls', ['-la']).stdout.on('data', d => console.log(d.toString()));

process Object

Property	Purpose
process.env	Environment variables
process.argv	CLI args ([node, script, ...args])
process.cwd()	Working directory
process.exit(code)	Exit with code
process.pid	Process ID
process.platform	OS (linux, darwin, win32)
process.version	Node version
process.memoryUsage()	Heap stats
process.uptime()	Seconds since start

process.on('SIGINT', () => { process.exit(0); });
process.on('uncaughtException', (e) => console.error(e));
process.on('unhandledRejection', (e) => console.error(e));

Streams

Type	Purpose
Readable	Source (fs.createReadStream)
Writable	Destination (fs.createWriteStream)
Duplex	Both (TCP socket)
Transform	Modify (zlib.createGzip)

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

await pipeline(
  createReadStream('in.txt'),
  createGzip(),
  createWriteStream('in.txt.gz')
);

Events

import { EventEmitter } from 'node:events';
const bus = new EventEmitter();
bus.on('event', fn);
bus.once('event', fn);
bus.emit('event', data);
bus.off('event', fn);

Worker Threads

// main.js
import { Worker } from 'node:worker_threads';
const w = new Worker('./worker.js');
w.on('message', (msg) => console.log(msg));
w.postMessage({ task: 'compute' });

// worker.js
import { parentPort } from 'node:worker_threads';
parentPort.on('message', (msg) => parentPort.postMessage('done'));

Common npm Scripts

{
  "scripts": {
    "start": "node index.js",
    "dev": "node --watch index.js",
    "test": "node --test",
    "build": "tsc",
    "lint": "eslint .",
    "format": "prettier --write ."
  }
}

package.json Fields

Field	Purpose
name	Package name
version	SemVer version
main	CJS entry point
module	ESM entry point
exports	Conditional exports
type	"module" for ESM
bin	CLI executables
engines	Node version range
scripts	Named tasks
dependencies	Runtime deps
devDependencies	Dev-only deps

Environment Variables

process.env.PORT ?? '3000';
process.env.NODE_ENV === 'production';

// Load .env
node --env-file=.env app.js;

Error Handling

// Try/catch with await
try { await fsp.readFile('f'); } catch (e) { console.error(e); }

// Unhandled rejections
process.on('unhandledRejection', console.error);

// HTTP errors
class NotFoundError extends Error { status = 404; }

Debugging

Tool	Use
node --inspect	Chrome DevTools / VS Code
node --inspect-brk	Break on first line
console.log	Quick debugging
node:util.inspect(obj, { depth: null })	Deep print
--trace-warnings	Show warning stack traces

Performance Flags

Flag	Purpose
--prof	V8 CPU profile
--prof-process	Read profile
--trace-opt	Log optimization
--trace-deopt	Log deoptimization
--max-old-space-size=4096	Heap limit
--max-semi-space-size=64	Young gen size

Cluster

import cluster from 'node:cluster';
import { cpus } from 'node:os';

if (cluster.isPrimary) {
  for (let i = 0; i < cpus().length; i++) cluster.fork();
} else {
  // worker: start server
  server.listen(3000);
}

Quick Tips

Do	Don’t
Use node: prefix	Rely on implicit core imports
Use fs/promises in async	Block loop with sync fs
Use pipeline for streams	Pipe manually (leaks)
Use --watch in dev	Restart manually
Use worker_threads for CPU	Block event loop
Use --env-file	Hardcode secrets
Use node --test	Assume no test runner

Status of Common Tasks

Task	Package
HTTP framework	Express, Fastify, Hono
Env vars	native --env-file, dotenv
Testing	native --test, vitest, jest
Linting	eslint
Logging	pino, winston
Config	convict, zod-validated env
Validation	zod, joi

Node.js — cheatsheet, not a chapter: flags, modules, event loop order, snippets, and the one-liners you actually reach for.

---

Stop using slow, ad-bloated tool sites! 🤮

🔎 Search “KandZ Tools” on Google to use many professional utilities for free.

KandZ.me is the ultimate minimalist hub for:
✅ Finance (Mortgage, Interest, Inflation)
✅ Tech (Base64, JSON, Dev Suite, IP)
✅ Health (BMI, BMR, TDEE)
✅ Productivity (Timer, Workspace, QR)

⚡️ Fast & Private
🔒 No data leaves your device
💎 100% Free

🔗 Use it now: https://tools.kandz.me
🔖 Bookmark it—you’ll need it later!