JavaScript Cheat Sheet

Updated 2026-07-16

🎯Take a practice test on this topic5 practice tests · 269 questions→

🧠Study flashcards on this topic183 cards · spaced repetition→

JavaScript is a dynamic, prototype-based programming language standardized as ECMAScript and used across browsers, servers (Node.js), and embedded runtimes. This cheat sheet covers the most-used language constructs, standard library APIs, and core Web/Node primitives — from everyday ES2015+ syntax through the newest ES2025/2026 features such as Iterator helpers, Set methods, explicit resource management, RegExp.escape, and Promise.try. Examples are intentionally minimal and runnable, emphasizing correct modern syntax, predictable semantics, and common pitfalls. Use the links in the first column as the source of truth for behavior, edge cases, and compatibility.

What This Cheat Sheet Covers

This topic spans 16 focused tables and 241 indexed concepts, 183 flashcards, 5 practice tests with 269 questions. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Core Types & EqualityTable 2: Declarations, Scope, and GlobalsTable 3: Functions and thisTable 4: Destructuring, Spread & PatternsTable 5: Objects, Prototypes, and ClassesTable 6: Arrays, Sets, and MapsTable 7: Iteration, Iterables, and GeneratorsTable 8: Strings and Regular ExpressionsTable 9: Control Flow, Operators, and ErrorsTable 10: Promises and AsyncTable 11: Modules and LoadingTable 12: Fetch and HTTP PrimitivesTable 13: DOM Events and StorageTable 14: Workers, Service Workers, and CachingTable 15: Node.js Runtime and I/OTable 16: Metaprogramming and Advanced Built-ins

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: Core Types & Equality

Every JavaScript value is one of eight primitive types or an Object. Knowing how primitives differ from reference types, how the three comparison algorithms (==, ===, and Object.is) treat NaN and -0, and why typeof null lies prevents a whole class of subtle bugs.

Type	Example	Description
typeof	`typeof "hello"` → `"string"`	• Returns a string naming the primitive type • `typeof null === "object"` is a legacy bug
Number	`0.1 + 0.2 !== 0.3`	• IEEE-754 64-bit floating point • all integers ≤ 2^53−1 are exact
BigInt	`9007199254740992n + 1n`	• Arbitrary-precision integers • append `n` • cannot mix with `Number` in arithmetic without explicit conversion (throws `TypeError`)
String	`"café".length` → `4`	• Immutable UTF-16 code-unit sequence • `.length` counts code units, so an emoji or surrogate pair counts as 2; use `[...str]` to count characters
Boolean	`Boolean(0)` → `false`	• Only `false`, `0`, `-0`, `0n`, `""`, `null`, `undefined`, `NaN` are falsy • every object (even `[]`) is truthy
null	`let x = null`	• Intentional absence of value • `typeof null` is `"object"` (legacy spec error).
undefined	`let y; y === undefined`	• Uninitialized variable or missing property • `null == undefined` is `true`, `null === undefined` is `false`.
Symbol	`Symbol("id") !== Symbol("id")`	• Always unique primitive • used for metaprogramming hooks and collision-free property keys
Object	`typeof {} === "object"`	• All non-primitives (arrays, functions, maps, …) are objects • assigned and compared by reference.
Strict equality (===)	`1 === "1"` → `false`	• Type-safe equality, no coercion • prefer over `==` to avoid coercion surprises
Object.is	`Object.is(NaN, NaN)` → `true`	• SameValue equality • treats `NaN` as equal and `-0` as distinct from `+0`, two cases `===` handles differently
Number.isNaN	`Number.isNaN(NaN)` → `true`	• Safer than global `isNaN` • no coercion, so returns `true` only for the actual `NaN` value
Number.isFinite	`Number.isFinite(Infinity)` → `false`	• Safer than global `isFinite` • rejects `Infinity`, `-Infinity`, and `NaN`, and non-numbers, without coercion
Number.isInteger	`Number.isInteger(1.0)` → `true`	• Returns `true` for a finite integer value (including `1.0`, since JS has no separate integer type) • no coercion
Number.isSafeInteger	`Number.isSafeInteger(2**53)` → `false`	• Safe range is `-(2^53−1)` to `2^53−1` • outside it, distinct integers collapse onto the same double.

Table 2: Declarations, Scope, and Globals

Choosing between let, const, and var is one of the first decisions in any JS file, but the real nuance is understanding hoisting, the temporal dead zone, and block vs. function scope. Getting this right eliminates entire classes of hard-to-debug state bugs.

Declaration	Example	Description
const	`const MAX = 100`	• Block-scoped • binding cannot be reassigned • object properties remain mutable • Default choice for all values

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

Table 3: Functions and `this`

Functions in JavaScript are first-class objects — they carry scope (closures), have their own this binding rules, and support multiple declaration styles with meaningfully different behavior. Arrow functions and closures are the two most important concepts to internalize first.

Concept	Example	Description
Arrow function	`const add = (a, b) => a + b`	• Concise syntax • lexically inherits `this` from enclosing scope • no `arguments` object

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

Table 4: Destructuring, Spread & Patterns

Destructuring and spread syntax are among the most frequently used modern JS features. They appear in every function signature, every import, and every data transformation. Mastering default values, renaming, and nested patterns is essential for writing idiomatic ES2015+ code.

Pattern	Example	Description
Array destructuring	`const [a, b] = [1, 2]`	• Binds elements by position • skip slots with commas: `const [,b] = arr`.

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

Table 1: Core Types & Equality

Type	Example	Description
typeof	`typeof "hello"` → `"string"`	• Returns a string naming the primitive type • `typeof null === "object"` is a legacy bug
Number	`0.1 + 0.2 !== 0.3`	• IEEE-754 64-bit floating point • all integers ≤ 2^53−1 are exact
BigInt	`9007199254740992n + 1n`	• Arbitrary-precision integers • append `n` • cannot mix with `Number` in arithmetic without explicit conversion (throws `TypeError`)
String	`"café".length` → `4`	• Immutable UTF-16 code-unit sequence • `.length` counts code units, so an emoji or surrogate pair counts as 2; use `[...str]` to count characters
Boolean	`Boolean(0)` → `false`	• Only `false`, `0`, `-0`, `0n`, `""`, `null`, `undefined`, `NaN` are falsy • every object (even `[]`) is truthy
null	`let x = null`	• Intentional absence of value • `typeof null` is `"object"` (legacy spec error).
undefined	`let y; y === undefined`	• Uninitialized variable or missing property • `null == undefined` is `true`, `null === undefined` is `false`.
Symbol	`Symbol("id") !== Symbol("id")`	• Always unique primitive • used for metaprogramming hooks and collision-free property keys
Object	`typeof {} === "object"`	• All non-primitives (arrays, functions, maps, …) are objects • assigned and compared by reference.
Strict equality (===)	`1 === "1"` → `false`	• Type-safe equality, no coercion • prefer over `==` to avoid coercion surprises
Object.is	`Object.is(NaN, NaN)` → `true`	• SameValue equality • treats `NaN` as equal and `-0` as distinct from `+0`, two cases `===` handles differently
Number.isNaN	`Number.isNaN(NaN)` → `true`	• Safer than global `isNaN` • no coercion, so returns `true` only for the actual `NaN` value
Number.isFinite	`Number.isFinite(Infinity)` → `false`	• Safer than global `isFinite` • rejects `Infinity`, `-Infinity`, and `NaN`, and non-numbers, without coercion
Number.isInteger	`Number.isInteger(1.0)` → `true`	• Returns `true` for a finite integer value (including `1.0`, since JS has no separate integer type) • no coercion
Number.isSafeInteger	`Number.isSafeInteger(2**53)` → `false`	• Safe range is `-(2^53−1)` to `2^53−1` • outside it, distinct integers collapse onto the same double.

Table 2: Declarations, Scope, and Globals

Declaration	Example	Description
const	`const MAX = 100`	• Block-scoped • binding cannot be reassigned • object properties remain mutable • Default choice for all values

Table 3: Functions and this

Concept	Example	Description
Arrow function	`const add = (a, b) => a + b`	• Concise syntax • lexically inherits `this` from enclosing scope • no `arguments` object

Table 4: Destructuring, Spread & Patterns

Pattern	Example	Description
Array destructuring	`const [a, b] = [1, 2]`	• Binds elements by position • skip slots with commas: `const [,b] = arr`.