The cheat page — JavaScript

Nothing new gets taught here. Every row links back to the chapter that actually explains the why — this page exists purely so the what is skimmable in one pass, table after table, instead of re-reading three levels of chapters the night before something matters.

Coercion & comparison, at a glance

null == undefined 0 == false "0" == 0 [] == false NaN == NaN null == 0 "" == "0"

Full coercion table and the non-transitivity proof: Operators & flow.

console.log(0.1 + 0.2);            // what happens?
console.log(0.1 + 0.2 === 0.3);    // what happens?

0.30000000000000004, then false. Not a JS bug — IEEE 754 floats can't represent 0.1 or 0.2 exactly in binary, in any language that uses them. Never compare floats with ===; compare Math.abs(a - b) < Number.EPSILON instead, or work in integers (cents, not dollars) where exactness actually matters.

	`===`	`Object.is()`
`NaN` vs `NaN`	false	true
`0` vs `-0`	true	false

Type checks, at a glance

Expression	Result
`typeof null`	`"object"` — a 25-year-old bug, permanent for compatibility
`typeof undefined`	`"undefined"`
`typeof NaN`	`"number"` — NaN IS a number, just not a useful one
`typeof []`	`"object"` — use `Array.isArray()`
`typeof function(){}`, `typeof class{}`	both `"function"`
`typeof Symbol()`, `typeof 10n`	`"symbol"`, `"bigint"`
`[1,2] === [1,2]`	`false` — different references, same shape

Full type system: Types & values. Reference vs primitive: same chapter.

Scope, closures, this — the 30-second version

Rank	Rule	Trigger
1	new	`new Fn()`
2	explicit	`.call()` / `.apply()` / `.bind()`
3	implicit	`obj.method()`
4	default	bare `fn()` → `undefined` in strict mode

Arrows never bind their own this — they read it from where they're written. The four rules and how this gets lost: The this keyword. The proof that new beats bind: Scope & functions, properly. All five real closure uses: Closures.

Array & object methods — mutates, or doesn't?

Mutates the original	Returns a new one, leaves the original alone
`push`, `pop`, `shift`, `unshift`	`slice`, `concat`, `map`, `filter`
`splice`, `sort`, `reverse`	`flat`, `flatMap`, spread `[...arr]`
`Object.assign(target, …)`	`{ ...obj }`, `structuredClone(obj)`

⚠ .map() skips holes in a sparse array Array(3).map(x => 1) is still [ <3 empty items> ], not [1, 1, 1] — Array(3) creates empty slots, not undefined values, and map/forEach/filter all skip holes entirely. Array.from({ length: 3 }) or Array(3).fill() first if you actually want real, mappable elements.

Full method tables: Objects & arrays (first half) and Objects deeply.

Async ordering — the one rule

Sync code runs first, always. Then the whole microtask queue drains (every .then(), every await continuation) — completely — before a single macrotask (setTimeout, a click) gets a turn.

Combinator	Settles when
`Promise.all`	all fulfill, or the first rejection
`Promise.allSettled`	everything has settled — never rejects itself
`Promise.race`	the first to settle, win or lose
`Promise.any`	the first to fulfill — ignores earlier rejections

Full step-through demos: Setup & mental model. Sequential-vs-parallel await, retries, AbortController: Async, properly.

Classes & prototypes — the 30-second version

obj.hasOwnProperty("x")     // true only for OWN properties, never inherited ones
Object.getPrototypeOf(obj)  // the real link an instance follows
Fn.prototype                // what becomes that link for every "new Fn()"
class B extends A {
  constructor() { super(); }   // MUST run before "this" is usable
}

The 4 steps new actually performs, and #private being parser-enforced: Prototypes & OOP.

"Implement X" — the classic from-scratch asks

Ask	Taught in
debounce / throttle	Closures
curry / partial application / compose	Scope & functions, properly, Patterns & architecture
memoize / once	Closures
your own EventEmitter / pub-sub	Patterns & architecture
deep clone	`structuredClone()` — Objects deeply
a concurrency-limited task queue	Advanced async
a custom iterable (`Symbol.iterator`)	Metaprogramming
`new` from scratch	Prototypes & OOP

The gotchas grid

{} + [] → 0 (statement position) [] + {} → "[object Object]" 1 < 2 < 3 → true 3 > 2 > 1 → false var in a loop + setTimeout → same value every time forEach can't be broken out of indexOf(NaN) is always -1 a bound "this" loses to new

Every one of these is explained, not just listed, in Operators & flow, Scope & functions, properly, and Objects & arrays.

Dry run: two gotchas from the grid above, traced

Expression	How the parser reads it	Result
{} + [] (as its own statement)	{} opens as an empty block statement, not an object literal; +[] is then a unary plus on an array, which coerces to 0	0
({} + []) or console.log({} + []) (expression position)	{} is now read as an object literal, so + is the binary operator; both sides stringify and concatenate	"[object Object]"
[] + {}	an array can never start a block, so this is always binary + regardless of position	"[object Object]"
1 < 2 < 3	left-to-right: (1 < 2) is true, then true < 3 coerces true to 1, and 1 < 3	true
3 > 2 > 1	left-to-right: (3 > 2) is true, then true > 1 coerces true to 1, and 1 > 1	false

Same {} + [], two different answers, purely from where it sits in the code — the exact trap the "(statement position)" note on the chip above is flagging. Chained comparisons resolve the same way: pairwise, left to right, each result coerced to a number before feeding the next comparison — never a genuine three-way check.

How to actually use this page

Don't start here. Every row above assumes the chapter behind its link has already been read once — this page is recall, not first exposure.
Cover the "Result" column with your hand and predict it before checking. Being surprised by a row you've "read" before is the actual signal it needs another real pass, not just a re-skim.
For the gotchas grid specifically: cover the chip past the arrow and say the reason out loud, not just the result — "why" is what an interviewer is actually asking for.
If a whole section reads unfamiliar rather than "oh right" — go read that chapter properly. This page is a mirror, not a shortcut past the mirror.

Before you move on

Predict a chip from the gotchas grid before checking the arrow, and explain the reason, not just the result.
Explain why {} + [] can equal both 0 and "[object Object]" depending on where it sits in code.
Say which of === and Object.is() treats NaN as equal to itself, and which treats 0 and -0 as different.
Name which array methods mutate their target, without checking the table.
Explain why 0.1 + 0.2 !== 0.3, using IEEE 754 floats, without opening the Operators & flow chapter.