# Node.js Cheat Sheet Course: [Node.js](https://www.devtutorials.ai/learn/nodejs) ยท Section: Project and Reference Source: https://www.devtutorials.ai/learn/nodejs/project-reference/cheat-sheet > A one-page Node.js reference: core modules, CommonJS and ES module patterns, event loop order, process, fs and path, EventEmitter, streams and buffers, HTTP and networking, child processes and workers, node:test, crypto, CLI flags, package.json fields and npm commands, plus common error codes, error messages with fixes, and a glossary for beginners. ## Node.js Cheat Sheet Every important Node.js API from this course, on one page. - Each table names the lesson that teaches it. - Code uses ES modules (`import`) unless it says CommonJS. - Keep this page open while you build your own projects. ## Core Modules Quick Reference | Module | What it does | Lesson | |---|---|---| | `node:fs/promises` | Read, write and manage files | Path and File System | | `node:path` | Build and split file paths | Path and File System | | `node:events` | `EventEmitter`, `once`, `on` | Events and Utilities | | `node:util` | `promisify`, `parseArgs`, `inspect`, `debuglog` | Events and Utilities | | `node:stream` | Readable, Writable, Transform, `pipeline` | Buffers, Streams and Compression | | `node:readline` | Read lines from files and stdin | Buffers, Streams and Compression | | `node:zlib` | gzip, deflate, Brotli | Buffers, Streams and Compression | | `node:http` | HTTP servers and clients | HTTP and Networking | | `node:net` | TCP sockets | HTTP and Networking | | `node:child_process` | Run other programs | Child Processes, Worker Threads and Clustering | | `node:worker_threads` | Run JavaScript on more threads | Child Processes, Worker Threads and Clustering | | `node:test`, `node:assert/strict` | Tests and checks | Testing with the Built-in Test Runner | | `node:crypto` | Hashes, HMAC, random values, encryption | Cryptography and Security | | `node:os` | Facts about the computer | Process, OS and CLI Tools | ## Module Patterns ```js // ES module (.mjs, or .js with "type": "module") import fs from "node:fs/promises"; import { average } from "./grades.js"; // full file name needed import data from "./data.json" with { type: "json" }; export function grade(m) { return m >= 90 ? "A" : "B"; } export default grade; const later = await import("./big-module.js"); // dynamic import, top-level await console.log(import.meta.dirname, import.meta.filename); ``` ```js // CommonJS (.cjs, or .js without "type": "module") const fs = require("node:fs"); const { average } = require("./grades"); // .js can be left out module.exports = { grade }; // never: exports = { ... } console.log(__dirname, __filename, require.main === module); ``` | Task | Code | Lesson | |---|---|---| | Use `require` inside ESM | `const require = createRequire(import.meta.url)` | Modules in Node.js | | Run TypeScript | `node app.ts` (types are stripped, not checked) | Modules in Node.js | | Package entry points | `"exports": { ".": "./index.js", "./grades": "./grades.js" }` | Packages and npm | | Private short names | `"imports": { "#config": "./src/config.js" }` | Packages and npm | ## Event Loop Order 1. All **sync code** from top to bottom. 2. **`process.nextTick`** callbacks. 3. **Promise** callbacks and `queueMicrotask`. 4. **Timers** phase: `setTimeout`, `setInterval`. 5. **Poll** phase: file and network callbacks. 6. **Check** phase: `setImmediate`. 7. **Close** callbacks. Then back to step 4. Steps 2 and 3 run again after every callback. | Task | Code | Lesson | |---|---|---| | Wait with await | `await setTimeout(500)` from `node:timers/promises` | Event Loop and Timers | | Let the loop breathe | `setImmediate(() => nextPiece())` | Event Loop and Timers | | Do not keep the program alive | `timer.unref()` | Event Loop and Timers | | Thread pool size | `UV_THREADPOOL_SIZE=8 node app.js` | Event Loop and Timers | ## process Methods | Task | Code | Lesson | |---|---|---| | Command words | `process.argv.slice(2)` | Process, OS and CLI Tools | | Settings | `process.env.PORT ?? "3000"` | Process, OS and CLI Tools | | Load a `.env` file | `node --env-file=.env app.js` or `process.loadEnvFile()` | Process, OS and CLI Tools | | Write without new line | `process.stdout.write("Loading...")` | Process, OS and CLI Tools | | Fail at the end | `process.exitCode = 1` | Process, OS and CLI Tools | | Stop now | `process.exit(1)` | Process, OS and CLI Tools | | Clean up on Ctrl + C | `process.on("SIGINT", cleanup)` | Process, OS and CLI Tools | | Polite stop | `process.on("SIGTERM", shutdown)` | Production Readiness | | Folder started from | `process.cwd()` | Process, OS and CLI Tools | | Memory and CPU | `process.memoryUsage()`, `process.cpuUsage()` | Debugging and Profiling | | Last safety net | `process.on("uncaughtException", logAndExit)` | Error Handling | ## fs and path Patterns ```js import { readFile, writeFile, mkdir, readdir, rename, rm, stat } from "node:fs/promises"; import path from "node:path"; const file = path.join(import.meta.dirname, "data", "marks.csv"); const text = await readFile(file, "utf8"); // text const json = JSON.parse(await readFile("config.json", "utf8")); // JSON await mkdir("reports/2026", { recursive: true }); await writeFile("report.json.tmp", JSON.stringify(json)); // safe write: await rename("report.json.tmp", "report.json"); // temp, then rename const entries = await readdir("reports", { withFileTypes: true }); const info = await stat("report.json"); // info.size, info.mtime await rm("old", { recursive: true, force: true }); ``` | Task | Code | Lesson | |---|---|---| | Glue path parts | `path.join("a", "b", "c.txt")` | Path and File System | | Absolute path | `path.resolve("reports")` | Path and File System | | Name, folder, extension | `path.basename(p)`, `path.dirname(p)`, `path.extname(p)` | Path and File System | | URL to path | `fileURLToPath(import.meta.url)` | Path and File System | | Write only if new | `writeFile(p, data, { flag: "wx" })` | Path and File System | ## EventEmitter Patterns ```js import { EventEmitter, once } from "node:events"; class Classroom extends EventEmitter { join(name) { this.emit("joined", name); } } const room = new Classroom(); room.on("joined", (name) => console.log("Hello", name)); // every time room.once("joined", () => console.log("First student!")); // one time room.on("error", (err) => console.error(err.message)); // always handle error const [name] = await once(room, "joined"); // wait for one event ``` ## Stream and Buffer Patterns ```js import { createReadStream, createWriteStream } from "node:fs"; import { createInterface } from "node:readline"; import { pipeline } from "node:stream/promises"; import { Transform } from "node:stream"; import { createGzip } from "node:zlib"; for await (const line of createInterface({ input: createReadStream("big.csv") })) { /* one line */ } await pipeline(createReadStream("log.txt"), createGzip(), createWriteStream("log.txt.gz")); const upper = new Transform({ transform(chunk, enc, done) { done(null, chunk.toString().toUpperCase()); } }); const buf = Buffer.from("Hi"); // buf.toString("base64"); // "SGk=" Buffer.from("SGk=", "base64").toString(); // "Hi" ``` | Task | Code | Lesson | |---|---|---| | Backpressure | `if (!out.write(chunk)) await once(out, "drain")` | Buffers, Streams and Compression | | Stream from a list | `Readable.from(["a", "b"])` | Buffers, Streams and Compression | | Copy part of a buffer | `Buffer.from(buf.subarray(0, 4))` | Buffers, Streams and Compression | ## HTTP and Networking Patterns ```js import http from "node:http"; const server = http.createServer(async (req, res) => { const { pathname, searchParams } = new URL(req.url, "http://localhost"); if (req.method === "POST") { let body = ""; for await (const chunk of req) body += chunk; res.writeHead(201, { "Content-Type": "application/json" }); return res.end(JSON.stringify({ saved: JSON.parse(body) })); } if (pathname === "/health") return res.writeHead(200).end("ok"); res.writeHead(404).end("Not found"); }); server.listen(3000); const reply = await fetch("http://localhost:3000/health", { signal: AbortSignal.timeout(2000) }); ``` | Task | Code | Lesson | |---|---|---| | Any free port | `server.listen(0)` then `server.address().port` | HTTP and Networking | | Port busy | `server.on("error", (e) => e.code === "EADDRINUSE")` | HTTP and Networking | | Serve a file | `createReadStream(file).pipe(res)` | HTTP and Networking | | Stop gracefully | `server.close(callback)` + `closeIdleConnections()` | Production Readiness | ## Child Process and Worker Patterns ```js import { execFile, spawn, fork } from "node:child_process"; import { promisify } from "node:util"; import { Worker, isMainThread, parentPort, workerData } from "node:worker_threads"; const { stdout } = await promisify(execFile)("git", ["log", "--oneline", "-3"]); // no shell const child = spawn("node", ["job.js"]); child.stdout.on("data", (d) => process.stdout.write(d)); if (isMainThread) { const w = new Worker(new URL(import.meta.url), { workerData: 1_000_000 }); w.on("message", (result) => console.log(result)); } else { parentPort.postMessage(heavyMaths(workerData)); } ``` ## node:test Patterns ```js import { test, describe, it, beforeEach, mock } from "node:test"; import assert from "node:assert/strict"; describe("grade", () => { beforeEach(() => { /* fresh data */ }); it("90 is an A", () => assert.equal(grade(90), "A")); it("objects", () => assert.deepStrictEqual({ a: [1] }, { a: [1] })); it("throws", () => assert.throws(() => parse("x"), TypeError)); it("rejects", async () => { await assert.rejects(load(99), /not found/); }); }); test("mocks", (t) => { const notify = mock.fn(); t.mock.timers.enable({ apis: ["setTimeout"] }); t.mock.timers.tick(1000); }); ``` | Task | Command | Lesson | |---|---|---| | Run all tests | `node --test` | Testing with the Built-in Test Runner | | Watch | `node --test --watch` | Testing with the Built-in Test Runner | | Coverage | `node --test --experimental-test-coverage` | Testing with the Built-in Test Runner | ## crypto Patterns ```js import { createHash, createHmac, randomBytes, randomUUID, scrypt, timingSafeEqual } from "node:crypto"; createHash("sha256").update("data").digest("hex"); // fingerprint createHmac("sha256", process.env.SECRET).update(msg).digest("hex"); // signature randomBytes(32).toString("hex"); // token randomUUID(); // id // passwords: salt + scrypt (or pbkdf2) + timingSafeEqual ``` ## CLI Flags | Flag | What it does | |---|---| | `-v`, `--version` | Print the Node.js version | | `-e "code"`, `-p "code"` | Run code, or run it and print the answer | | `-c`, `--check` | Check a file for syntax errors | | `--watch` | Restart when files change | | `--env-file=.env` | Load settings into `process.env` | | `--run