JavaScript Cheat Sheet

01Declaring Variablesblock scope by default

const pi = 3.14★
Block-scoped, can't be reassigned. Your default.
let count = 0★
Block-scoped and reassignable. Use when it changes.
var x = 1avoid
Function-scoped, hoisted as undefined — legacy.
const { a, b } = obj
Destructure fields into variables.
const [x, y] = arr
Destructure array elements by position.
a = b = 5
Chained assignment; const can't be reassigned.

02Types & Checking7 primitives + object

typeof v★
"string" "number" "boolean" "undefined" "symbol" "bigint" "function" "object".
typeof null === "object"
A 1995 bug that can never be fixed. It's really null.
Array.isArray(v)
The right way to test for an array.
Number.isNaN(v)
Only true for the actual NaN value.
Number.isInteger(v)
Whole-number check, no coercion.
v instanceof Date
Is v built from this constructor / prototype chain?

03Operatorsthe daily grammar

a === b a !== b★
Strict equality — no type coercion. Always prefer.
a == bcoerces
Loose equality converts types first — surprising.
&& || !
Logical and / or / not. && & || short-circuit & return an operand.
a ?? b★ES2020
Nullish coalescing — fall back only if a is null/undefined.
obj?.a?.m?.()★ES2020
Optional chaining — stop & give undefined if any link is nullish.
cond ? x : y★
Ternary — the only operator taking 3 operands.
a ??= b a ||= b a &&= bES2021
Logical assignment — assign only if the test passes.
2 ** 10
Exponentiation → 1024. Same as Math.pow.
...arr ...obj★
Spread — expand into a new array / object / call args.

04Stringsimmutable text

`hi ${name}, ${1+1}`★
Template literal — interpolation + multi-line.
s.includes("ab")★
Also startsWith / endsWith → boolean.
s.slice(1, 4)
Substring; negatives count from the end.
s.replaceAll("a", "b")ES2021
replace hits only the first; this hits all.
s.split(",") arr.join(",")★
String ⇄ array, the two directions.
s.trim() .padStart(3,"0")
Strip edges; left-pad (also padEnd).
s.at(-1)ES2022
Last char via negative index — cleaner than s[s.length-1].
String(v) Number(s)
Explicit conversion — clearer than +v / ``+v.

05Numbers & Mathall floats (IEEE-754)

0.1 + 0.2 !== 0.3★
Binary floats → 0.30000000000000004. Round before comparing.
(3.14159).toFixed(2)
→ "3.14" — note: returns a string.
parseInt(s, 10) parseFloat(s)
Parse leading number; always pass the radix.
Math.round .floor .ceil .trunc
Rounding family; trunc just drops the decimals.
Math.max(...a) Math.random()
Spread an array into max/min; random ∈ [0,1).
1_000_000ES2021
Numeric separators — digits only, purely cosmetic.
9007199254740993nES2020
BigInt — integers beyond Number.MAX_SAFE_INTEGER.

06Arrays · build & findordered lists

[...a, ...b]★
Merge / copy (shallow) via spread.
Array.from({length:3}, (_,i)=>i)
Build from iterable/length → [0,1,2].
a.includes(x) a.indexOf(x)★
Membership (bool) vs position (−1 if absent).
a.find(x=>x>3) .findIndex()★
First match by predicate — value or index.
a.findLast() .findLastIndex()ES2023
Same search, walking from the end.
a.some(p) a.every(p)
Any match? / all match? → boolean.
a.at(-1)★ES2022
Last element without a[a.length-1].

07Arrays · transformcopy vs mutate

a.map(x=>x*2)★
New array, one output per input.
a.filter(x=>x>0)★
New array, only elements passing the test.
a.reduce((s,x)=>s+x, 0)★
Fold to a single value; always pass the seed.
a.forEach(x=>log(x))
Side effects only — returns undefined.
a.flat() a.flatMap(f)
Un-nest one level / map-then-flatten.
a.sort((x,y)=>x-y)mutates
Default sorts as strings! Pass a comparator for numbers.
a.push .pop .splice .reversemutates
Change the array in place.
a.toSorted() .toReversed()ES2023
Copying twins — leave the original untouched.
a.with(1, "x") .toSpliced()ES2023
Copy with one index changed / spliced.

08Objectskey → value maps

{ name, age, [key]: v }★
Shorthand props + computed keys.
{ ...base, id: 1 }★
Spread-copy then override (shallow).
Object.keys .values .entries(o)★
Arrays of keys / values / [k,v] pairs to loop.
Object.fromEntries(pairs)
Rebuild an object from [k,v] pairs — inverse of entries.
Object.hasOwn(o, "k")ES2022
Safe own-property check; replaces hasOwnProperty.
Object.freeze(o)
Make shallowly immutable (silently ignores writes).
Object.groupBy(arr, x=>x.type)ES2024
Bucket items into an object keyed by the callback.

09Destructuring & Restunpack & gather

const { a, b = 10 } = obj
Pull fields, with a default if missing.
const { a: x } = obj
Rename while unpacking → new var x.
const [first, ...rest] = arr★
Head + gather the tail into an array.
const { a, ...others } = obj
Rest collects the remaining own keys.
[a, b] = [b, a]
Swap two variables, no temp needed.
const {a:{b}} = obj
Nested destructuring reaches deep values.

10Functionsfirst-class values

function add(a, b) { return a+b }
Declaration — hoisted, callable before its line.
const add = (a, b) => a + b★
Arrow — concise; implicit return, no own this.
(x) => ({ x })
Wrap an object literal in () or it reads as a block.
greet(name = "friend")★
Default parameters fill in for undefined.
sum(...nums)
Rest params gather all args into a real array.
(function(){ ... })()
IIFE — run once, keep names private.
function outer(){ let n=0; return ()=>++n }
Closure — inner fn keeps access to outer's vars.

11this & bindingset by the call site

obj.method()★
Implicit: this = the object left of the dot.
new Thing()
new: this = the fresh instance.
f.call(ctx, a) f.apply(ctx, [a])
Explicit: you pass this in directly.
const g = f.bind(ctx)
Returns a copy permanently locked to ctx.
setTimeout(obj.m)
Bare call loses this → default (undefined in strict).
() => this.x★
Arrows have no own this — they inherit lexically. Ideal for callbacks.

12Classessyntax over prototypes

class Dog { constructor(n){ this.n=n } }★
Runs on new; sets up the instance.
bark(){ ... }
Methods live on the prototype, shared by all instances.
get area(){} set area(v){}
Accessors — used like a property, run like a method.
static from(x){ ... }
Called on the class itself, not instances.
class Pup extends Dog { }
Inherit; call super(...) first in the constructor.
#secret = 0ES2022
True private field — unreachable outside the class.
static { ... }ES2022
Static init block — one-time class setup.

13Control Flowbranch & loop

if (c) { } else if (d) { } else { }
Standard branching.
switch (v) { case 1: ...; break; }
Multi-way; break or cases fall through.
for (const x of arr)★
Iterate values of any iterable. Your default loop.
for (const k in obj)
Iterates keys (incl. inherited) — for objects, not arrays.
while (c) { } do { } while (c)
Condition-first vs run-at-least-once.
break continue
Exit the loop / skip to the next iteration.

14Iterators & Generatorslazy sequences

function* ids(){ yield 1; yield 2 }★
Generator — yield pauses & resumes; produces values on demand.
const g = ids(); g.next()
{ value, done } each call, until done.
[...ids()] for (const x of ids())
Spread / loop consume any iterable.
[Symbol.iterator]() { ... }
Make your own object iterable by adding this method.
async function* stream()
Async generator — for await (const x of ...).

15Promisesa future value

p.then(v=>...).catch(e=>...)★
Handle success / failure; .finally() runs either way.
Promise.resolve(v) .reject(e)
Make an already-settled promise.
Promise.all([p1, p2])★
Wait for all; rejects fast if any one fails.
Promise.allSettled([...])ES2020
Wait for all; never rejects — array of outcomes.
Promise.any([...])ES2021
First to fulfil wins; ignores rejections.
Promise.race([...])
First to settle (win or lose) wins.
Promise.withResolvers()ES2024
Get { promise, resolve, reject } to settle from outside.

16async / awaitpromises, written flat

async function f(){ return 1 }★
Always returns a Promise (wraps the value).
const data = await fetch(url)★
Pause until it settles; unwrap the value.
try { await f() } catch (e) { }★
Rejections throw — catch them like sync errors.
const [a, b] = await Promise.all([...])
Run in parallel; don't await in a loop serially.
await f() // top levelES2022
Top-level await — in modules, no wrapper needed.
arr.forEach(async ...)
forEach ignores the promises — use for...of + await.

17Map & Setkeyed & unique

const m = new Map()★
Any-type keys, ordered, real .size. Beats {} for dynamic keys.
m.set(k, v) m.get(k) m.has(k)
Core map ops; set chains.
const s = new Set([1,1,2])★
Unique values; [...new Set(arr)] dedupes an array.
s.add(x) s.has(x) s.delete(x)
Set membership in O(1).
new WeakMap() new WeakSet()
Object keys held weakly — GC can reclaim them.
Map.groupBy(arr, fn)ES2024
Like Object.groupBy but keys can be any type.

18JSON & Cloningserialize & copy

JSON.stringify(obj)★
Object → JSON string.
JSON.stringify(o, null, 2)
Third arg = indent for pretty output.
JSON.parse(str)★
JSON string → object. Throws on bad input — wrap in try.
JSON.parse(JSON.stringify(o))
Old deep-clone hack — drops functions, Dates, undefined.
structuredClone(obj)★ES2022
Real deep clone — handles Dates, Maps, cycles.

19Regular Expressionspattern matching

/ab+c/gi
Literal + flags: global ignore-case multiline sdotall.
re.test(s)
Boolean — does it match anywhere?
s.match(re) s.matchAll(re)
One match / iterator of all matches (needs g).
s.replace(re, "$1")
$1 = capture group; a fn as arg = computed replace.
/(?<year>\d{4})/
Named group → m.groups.year.
/[\p{Emoji}]/vES2024
v flag — set operations & string properties in classes.

20Error Handlingthrow & catch

try { } catch (e) { } finally { }★
finally always runs — cleanup goes here.
throw new Error("msg")★
Throw an Error object, not a bare string.
TypeError RangeError SyntaxError
Built-in subclasses — check e instanceof TypeError.
class AppError extends Error {}
Custom errors — subclass Error, set this.name.
new Error("x", { cause: err })ES2022
Chain the original error for context.

21Modulesimport / export (ESM)

export function f(){} export const x★
Named exports — many per file.
export default App
One default per file — the "main" thing.
import { f, x } from "./m.js"★
Named imports — braces & matching names.
import App from "./app.js"
Default import — no braces, name is yours.
import * as utils from "./u.js"
Namespace — all named exports on one object.
const m = await import("./m.js")ES2020
Dynamic import — load on demand, returns a Promise.

JS JavaScript cheat sheet

The ECMAScript timeline

Four ideas worth seeing

Primitives copy · objects share

The prototype chain

Microtasks jump the queue

What `this` is — read the call site

Worth memorizing