📖 Guide
Node.js — Complete Reference
Comprehensive Node.js runtime cheat sheet covering modules, file system, HTTP, streams, child processes, and common patterns.
113 commands across 11 categories
Getting StartedModules (require/import)File System (fs)PathHTTPEventsStreamsProcess & OSChild Processesnpm ScriptsCommon Patterns
Getting Started
| Command | Description |
|---|---|
node app.js | Run a JavaScript file with Node.js |
node -e 'console.log(1+1)' | Evaluate inline JavaScript expression |
node --watch app.js | Run file and restart on changes (Node 18+) |
node --inspect app.js | Start with debugger listening on port 9229 |
node --env-file=.env app.js | Load environment variables from file (Node 20+) |
node -p 'process.versions' | Print Node.js and dependency versions |
node --check app.js | Syntax-check a file without executing it |
node -r ts-node/register app.ts | Preload a module before running (e.g. ts-node) |
node --max-old-space-size=4096 app.js | Increase V8 heap memory limit to 4 GB |
node --teste.g. node --test tests/*.js | Run built-in test runner (Node 18+) |
Modules (require/import)
| Command | Description |
|---|---|
const fs = require('fs'); | Import a CommonJS module |
import fs from 'fs'; | Import an ES module (requires type: module or .mjs) |
import { readFile } from 'fs/promises'; | Named import from a module |
module.exports = { fn }; | Export from a CommonJS module |
export default function() {} | Default export from an ES module |
export { helper, utils }; | Named exports from an ES module |
const mod = await import('./mod.js'); | Dynamic import (works in both CJS and ESM) |
require.resolve('express') | Get the resolved file path of a module without loading it |
import.meta.url | Get the file URL of the current ES module |
import { createRequire } from 'module';e.g. const require = createRequire(import.meta.url); | Use require() inside ES modules |
File System (fs)
| Command | Description |
|---|---|
fs.readFileSync('file.txt', 'utf8') | Read a file synchronously as a string |
await fs.promises.readFile('f.txt', 'utf8') | Read a file asynchronously with promises |
fs.writeFileSync('out.txt', data) | Write data to a file (overwrites existing) |
fs.appendFileSync('log.txt', line) | Append data to a file |
fs.existsSync('/path/to/file') | Check if a file or directory exists |
fs.mkdirSync('dir', { recursive: true }) | Create a directory and any missing parents |
fs.readdirSync('dir') | List files and directories in a folder |
fs.unlinkSync('file.txt') | Delete a file |
fs.renameSync('old.txt', 'new.txt') | Rename or move a file |
fs.statSync('file.txt').isFile() | Get file stats (size, modified time, type) |
fs.copyFileSync('src.txt', 'dst.txt') | Copy a file |
fs.watch('dir', callback) | Watch a file or directory for changes |
Path
| Command | Description |
|---|---|
path.join('dir', 'file.txt')e.g. // 'dir/file.txt' | Join path segments with OS separator |
path.resolve('relative/path') | Resolve to an absolute path from cwd |
path.basename('/dir/file.txt')e.g. // 'file.txt' | Get the filename from a path |
path.dirname('/dir/file.txt')e.g. // '/dir' | Get the directory from a path |
path.extname('file.txt')e.g. // '.txt' | Get the file extension |
path.parse('/dir/file.txt') | Parse path into { root, dir, base, ext, name } |
path.relative('/a/b', '/a/c')e.g. // '../c' | Get relative path between two paths |
path.isAbsolute('/usr/bin') | Check if a path is absolute |
path.normalize('a//b/../c')e.g. // 'a/c' | Normalize a path resolving . and .. |
path.sep | OS-specific path separator ('/' or '\\') |
HTTP
| Command | Description |
|---|---|
http.createServer((req, res) => { res.end('OK'); }).listen(3000); | Create a basic HTTP server on port 3000 |
res.writeHead(200, { 'Content-Type': 'application/json' }); | Set response status code and headers |
res.end(JSON.stringify(data)); | Send response body and end the response |
req.method | Get the HTTP method (GET, POST, etc.) |
req.url | Get the request URL path and query string |
new URL(req.url, 'http://localhost').searchParams | Parse query parameters from the request URL |
http.get(url, (res) => { ... }); | Make a simple HTTP GET request |
const res = await fetch(url);e.g. const data = await res.json(); | Fetch API (built-in Node 18+) |
http.request({ method: 'POST', ... }, callback); | Make an HTTP request with full options |
server.close(); | Stop the HTTP server from accepting new connections |
Events
| Command | Description |
|---|---|
const emitter = new EventEmitter(); | Create a new event emitter instance |
emitter.on('event', callback) | Register a listener for an event |
emitter.once('event', callback) | Register a one-time listener (auto-removed after first call) |
emitter.emit('event', arg1, arg2) | Emit an event with arguments |
emitter.off('event', callback) | Remove a specific event listener |
emitter.removeAllListeners('event') | Remove all listeners for an event |
emitter.listenerCount('event') | Get the number of listeners for an event |
emitter.setMaxListeners(20) | Increase max listener limit (default 10) to avoid warnings |
const { on } = require('events');e.g. for await (const [msg] of on(emitter, 'data')) { } | Async iterator for events |
Streams
| Command | Description |
|---|---|
fs.createReadStream('file.txt') | Create a readable stream from a file |
fs.createWriteStream('out.txt') | Create a writable stream to a file |
readable.pipe(writable) | Pipe a readable stream into a writable stream |
await pipeline(readable, transform, writable); | Pipe streams with error handling (from stream/promises) |
readable.on('data', (chunk) => { }) | Read data chunks as they arrive |
writable.write(chunk) | Write a chunk to a writable stream |
writable.end() | Signal no more data will be written |
new Transform({ transform(chunk, enc, cb) { cb(null, modified); } }) | Create a transform stream to modify data in transit |
Readable.from(iterable) | Create a readable stream from an array or async iterable |
stream.Readable.toWeb(nodeStream) | Convert a Node stream to a Web ReadableStream (Node 17+) |
Process & OS
| Command | Description |
|---|---|
process.env.NODE_ENV | Access an environment variable |
process.argve.g. // ['node', 'app.js', '--port', '3000'] | Get command-line arguments array |
process.cwd() | Get the current working directory |
process.exit(1) | Exit with a status code (0 = success, non-zero = error) |
process.pid | Get the current process ID |
process.memoryUsage() | Get memory usage (rss, heapTotal, heapUsed, external) |
process.on('uncaughtException', (err) => { }) | Handle uncaught exceptions globally |
process.on('SIGINT', () => { }) | Handle Ctrl+C / interrupt signal |
os.cpus().length | Get the number of CPU cores |
os.totalmem() / 1024 ** 3 | Get total system memory in GB |
os.platform() | Get the OS platform (linux, darwin, win32) |
os.homedir() | Get the current user's home directory |
Child Processes
| Command | Description |
|---|---|
execSync('ls -la', { encoding: 'utf8' }) | Execute a shell command synchronously and return output |
exec('ls -la', (err, stdout, stderr) => { }) | Execute a shell command asynchronously |
const { stdout } = await execPromise('ls');e.g. const execPromise = util.promisify(exec); | Promisified exec |
spawn('node', ['app.js']) | Spawn a child process (no shell, streamed output) |
child.stdout.on('data', (data) => { }) | Listen to stdout of a spawned process |
child.on('exit', (code) => { }) | Handle child process exit |
fork('worker.js') | Spawn a Node.js child process with IPC channel |
child.send({ type: 'work', data }) | Send a message to a forked child process |
process.on('message', (msg) => { }) | Receive messages in a forked child process |
execFileSync('git', ['status']) | Execute a file directly without shell (safer, no injection) |
npm Scripts
| Command | Description |
|---|---|
npm init -y | Create a package.json with default values |
npm install express | Install a package as a dependency |
npm install -D typescript | Install a package as a dev dependency |
npm run build | Run a script defined in package.json |
npm start | Run the 'start' script (shorthand, no 'run' needed) |
npm test | Run the 'test' script (shorthand) |
npx create-next-app@latest | Run a package binary without installing globally |
npm ls --depth=0 | List top-level installed packages |
npm outdated | Check for outdated packages |
npm audit fix | Automatically fix known security vulnerabilities |
Common Patterns
| Command | Description |
|---|---|
setTimeout(() => { }, 1000) | Execute code after a delay (milliseconds) |
setInterval(() => { }, 5000) | Execute code repeatedly at an interval |
await new Promise(r => setTimeout(r, 1000)); | Async sleep / delay |
JSON.parse(fs.readFileSync('data.json', 'utf8')) | Read and parse a JSON file |
const __dirname = path.dirname(fileURLToPath(import.meta.url)); | Get __dirname in ES modules |
crypto.randomUUID() | Generate a random UUID (Node 14.17+) |
crypto.createHash('sha256').update(data).digest('hex') | Hash a string with SHA-256 |
Buffer.from(str, 'utf8').toString('base64') | Encode a string to base64 |
process.hrtime.bigint() | High-resolution timer for benchmarking (nanoseconds) |
util.promisify(fs.readFile) | Convert a callback-based function to return a promise |
📖 Free, searchable command reference. Bookmark this page for quick access.