Node.js Cheat Sheet

By Syncfusion®, Inc. · Last updated November 13, 2026

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 Patterns

// 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);

// 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);

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.

process Methods

fs and path Patterns

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 });

EventEmitter Patterns

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

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");               // <Buffer 48 69>
buf.toString("base64");                      // "SGk="
Buffer.from("SGk=", "base64").toString();    // "Hi"

HTTP and Networking Patterns

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) });

Child Process and Worker Patterns

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

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);
});

crypto Patterns

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

package.json Fields

npm Commands

Troubleshooting

Common Error Codes

Common Error Messages and Fixes

Glossary

What to Remember

• Use this page to look things up, and the lessons to understand them.
• Start new projects with ES modules, fs/promises and node --test.
• When an error appears, check its code first, then this page's tables.

Next: Introduction to Express.js in the Express.js course. You will build web servers faster with a framework on top of everything you learned here.