Node.js Cheat Sheet

Updated 2026-07-16

Next Topic: OAuth 2.0 and Authorization Flows Cheat Sheet

🎯Take a practice test on this topic7 practice tests · 259 questions→

🧠Study flashcards on this topic140 cards · spaced repetition→

Node.js is a server-side JavaScript runtime built on Chrome's V8 engine, designed for building scalable network applications. It uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, particularly well-suited for data-intensive real-time applications. As of Node.js 26 (released April 2026, the last release under the old even/odd LTS model), the runtime has reached a "batteries-included" maturity, with native TypeScript type stripping, a built-in Permission Model, native fetch() and WebSocket client, a built-in SQLite module, and a built-in test runner that eliminate many previously required npm dependencies. Understanding Node.js means understanding that most operations are asynchronous by default and that the event loop's single-threaded model shapes every architectural decision.

What This Cheat Sheet Covers

This topic spans 22 focused tables and 206 indexed concepts, 140 flashcards, 7 practice tests with 259 questions. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Runtime & ArchitectureTable 2: Asynchronous PatternsTable 3: Module SystemTable 4: Core Modules - File SystemTable 5: Core Modules - StreamsTable 6: Core Modules - HTTP & NetworkingTable 7: Built-in Web-Standard APIsTable 8: Core Modules - Process & EnvironmentTable 9: Core Modules - EventsTable 10: Core Modules - TimersTable 11: Core Modules - Path & URLTable 12: Core Modules - UtilitiesTable 13: Core Modules - Crypto & SecurityTable 14: Core Modules - Child Processes & ConcurrencyTable 15: npm & Package ManagementTable 16: package.json ConfigurationTable 17: Error HandlingTable 18: Performance & MonitoringTable 19: TestingTable 20: Debugging & CLI ToolsTable 21: OS & System InformationTable 22: Advanced Core Modules

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Runtime & Architecture

To reason about Node.js performance, you first have to understand the machinery underneath your code: the V8 engine that compiles your JavaScript, libuv that supplies the event loop and thread pool, and the single-threaded, event-driven model that ties them together. These concepts explain why Node excels at I/O-heavy workloads and why blocking the event loop is the cardinal sin. The last few rows cover the developer-facing surface (--watch, native TypeScript, and the REPL) that has made the modern runtime feel batteries-included.

Concept	Example	Description
Event Loop	Processes callbacks from timers, I/O, and setImmediate queues in phases	• Core mechanism enabling non-blocking I/O • continuously cycles through six phases (timers, pending callbacks, idle/prepare, poll, check, close callbacks); each phase owns a FIFO queue, so a callback runs in the phase matching its kind of work, not in scheduling order.
V8 Engine	Compiles JS to machine code using JIT compilation	• Google's open-source JavaScript engine that powers Node.js • JIT-compiles rather than merely interpreting (Ignition interpreter feeding the TurboFan optimizing compiler), and handles memory allocation and garbage collection; Node.js 26 ships V8 14.6.
libuv	Cross-platform async I/O library underneath Node.js	• Provides the event loop and a thread pool (default 4 threads, tunable via `UV_THREADPOOL_SIZE`) used by file system, `dns.lookup()`, `crypto` and `zlib` work • network I/O does NOT use the pool: it goes through the kernel (epoll/kqueue/IOCP).
Non-blocking I/O	`fs.readFile(path, callback)` returns immediately	• Operations return control immediately, they are not finished when the call returns • results are delivered later via callbacks, promises, or async/await.
Single-threaded	Main event loop runs on one thread	• JavaScript execution stays on a single thread, while I/O operations are delegated to the kernel or thread pool • a long synchronous callback therefore stalls every pending client, which is a DoS risk as well as a performance one.
Event-driven	Uses EventEmitter pattern for async communication	Many core APIs signal completion by emitting named events (`net.Server` on connect, `fs.ReadStream` on open), which listeners registered with `.on()` handle asynchronously.
--watch mode	`node --watch app.js` `node --watch-path=./src app.js`	• Built-in file watcher since Node.js 18.11 • restarts the whole process on file changes (it is not hot module replacement, so in-memory state is lost); a simpler nodemon alternative, with `--watch-path` for scoping to specific directories.
Native TypeScript	`node example.ts`	• Type stripping runs `.ts` files with no flags since v22.18 (disable with `--no-strip-types`), using the Amaro library, so no `ts-node` or build step is required • erasable syntax only (`enum`, parameter properties need more) and no type checking is performed: run `tsc --noEmit` separately.
REPL	`node` in terminal launches interactive shell	• Read-Eval-Print-Loop environment for interactive JavaScript • useful for quick testing and debugging single expressions; it prints the value of each expression entered.

Table 2: Asynchronous Patterns

Because nearly everything in Node is asynchronous, the way you orchestrate that asynchrony shapes your whole codebase. async/await is the syntax you'll reach for daily, but the four Promise combinators each answer a different question: must everything succeed (all), do I want every outcome regardless (allSettled), who finishes first (race), or who succeeds first (any). The remaining rows cover cancellation with AbortController, context propagation with AsyncLocalStorage, and the older callback world you'll still meet at the edges.

Pattern	Example	Description
async/await	`import { readFile } from 'node:fs/promises';` `const data = await readFile('file.txt');`	• Modern syntax for consuming promises, making async code read top-to-bottom while staying non-blocking • an `async` function always returns a promise • `await` in a loop runs calls one after another; use `Promise.all()` to start them together.

The rest of this section is part of the full cheat sheet

Table 3: Module System

Node runs two module systems side by side, and a surprising share of confusing Node errors trace back to which one a given file is using. ESM with import/export is the standard for new code, while require() and module.exports still power a huge installed base and remain fully supported. The rows below cover both syntaxes plus the "type" field and the .mjs/.cjs extensions that decide how Node reads any given file.

Type	Example	Description
ES Modules (ESM)	`import fs from 'node:fs';` `export const foo = 42;`	• Modern JavaScript module standard using `import` and `export` syntax • enabled by `"type": "module"` in package.json or the `.mjs` extension, and the only module system where top-level `await` works.

The rest of this section is part of the full cheat sheet

Table 4: Core Modules - File System

The fs module is your gateway to the disk: reading, writing, appending, listing directories, and copying or deleting files. Two themes are worth noticing. The fs.promises variants pair naturally with async/await, and every whole-file method here loads the entire file into memory before it returns, so for anything large you want the streaming methods at the bottom (createReadStream/createWriteStream) instead.

Method	Example	Description
fs.readFile()	`fs.readFile('file.txt', 'utf8', (err, data) => {})`	• Asynchronously reads an entire file into memory • with no encoding you get a `Buffer`, with `'utf8'` you get a string; `fs.promises.readFile()` fits async/await usage.

The rest of this section is part of the full cheat sheet

Table 1: Runtime & Architecture

Concept	Example	Description
Event Loop	Processes callbacks from timers, I/O, and setImmediate queues in phases	• Core mechanism enabling non-blocking I/O • continuously cycles through six phases (timers, pending callbacks, idle/prepare, poll, check, close callbacks); each phase owns a FIFO queue, so a callback runs in the phase matching its kind of work, not in scheduling order.
V8 Engine	Compiles JS to machine code using JIT compilation	• Google's open-source JavaScript engine that powers Node.js • JIT-compiles rather than merely interpreting (Ignition interpreter feeding the TurboFan optimizing compiler), and handles memory allocation and garbage collection; Node.js 26 ships V8 14.6.
libuv	Cross-platform async I/O library underneath Node.js	• Provides the event loop and a thread pool (default 4 threads, tunable via `UV_THREADPOOL_SIZE`) used by file system, `dns.lookup()`, `crypto` and `zlib` work • network I/O does NOT use the pool: it goes through the kernel (epoll/kqueue/IOCP).
Non-blocking I/O	`fs.readFile(path, callback)` returns immediately	• Operations return control immediately, they are not finished when the call returns • results are delivered later via callbacks, promises, or async/await.
Single-threaded	Main event loop runs on one thread	• JavaScript execution stays on a single thread, while I/O operations are delegated to the kernel or thread pool • a long synchronous callback therefore stalls every pending client, which is a DoS risk as well as a performance one.
Event-driven	Uses EventEmitter pattern for async communication	Many core APIs signal completion by emitting named events (`net.Server` on connect, `fs.ReadStream` on open), which listeners registered with `.on()` handle asynchronously.
--watch mode	`node --watch app.js` `node --watch-path=./src app.js`	• Built-in file watcher since Node.js 18.11 • restarts the whole process on file changes (it is not hot module replacement, so in-memory state is lost); a simpler nodemon alternative, with `--watch-path` for scoping to specific directories.
Native TypeScript	`node example.ts`	• Type stripping runs `.ts` files with no flags since v22.18 (disable with `--no-strip-types`), using the Amaro library, so no `ts-node` or build step is required • erasable syntax only (`enum`, parameter properties need more) and no type checking is performed: run `tsc --noEmit` separately.
REPL	`node` in terminal launches interactive shell	• Read-Eval-Print-Loop environment for interactive JavaScript • useful for quick testing and debugging single expressions; it prints the value of each expression entered.

Table 2: Asynchronous Patterns

Pattern	Example	Description
async/await	`import { readFile } from 'node:fs/promises';` `const data = await readFile('file.txt');`	• Modern syntax for consuming promises, making async code read top-to-bottom while staying non-blocking • an `async` function always returns a promise • `await` in a loop runs calls one after another; use `Promise.all()` to start them together.

Table 3: Module System

Type	Example	Description
ES Modules (ESM)	`import fs from 'node:fs';` `export const foo = 42;`	• Modern JavaScript module standard using `import` and `export` syntax • enabled by `"type": "module"` in package.json or the `.mjs` extension, and the only module system where top-level `await` works.

Table 4: Core Modules - File System

Method	Example	Description
fs.readFile()	`fs.readFile('file.txt', 'utf8', (err, data) => {})`	• Asynchronously reads an entire file into memory • with no encoding you get a `Buffer`, with `'utf8'` you get a string; `fs.promises.readFile()` fits async/await usage.