Errors and Built-in Objects

JavaScript throws TypeError when a value is the wrong kind of thing for the operation, ReferenceError when an identifier does not resolve, RangeError when a value of the right type is out of range, SyntaxError when source cannot be parsed, and URIError for malformed URI escapes.

JavaScript's throw accepts any value: strings, numbers, plain objects, null, even undefined. Only Error instances carry name, message and a stack, so a thrown string leaves the catch block with no diagnostics, err.message undefined, and err instanceof Error false.

A JavaScript finally block runs on every exit from its try statement - normal completion, an early return, a break or continue, a caught error, and an error still propagating outward - which is exactly why cleanup belongs there.

The name property is inherited from Error.prototype, whose value is the string Error; an empty subclass overrides nothing. A correct custom error calls super(message) and then assigns its own name, plus whatever structured fields callers need.

A bare throw err rethrows the identical object, so its type, custom properties and original stack all survive. throw new Error(err.message) starts a fresh error and discards them. Logging and returning is worst: the caller sees a successful call and a bogus value.

JSON.stringify silently drops undefined, function and symbol object properties, turns those same values into null inside arrays, and returns the value undefined — not a string — when you pass one directly as the top-level argument.

JSON.stringify() converts a JavaScript value into a string of JSON text; JSON.parse() turns such a string back into a JavaScript value. The result is a brand-new object graph that shares no references with the original.

The replacer is JSON.stringify's second argument. An array of keys acts as an allowlist that also fixes the output key order; a function is called for every key and value pair and returns the value to serialize, or undefined to omit that property.

JSON.stringify's third parameter, space, controls indentation: pass a number of spaces or an indent string, as in JSON.stringify(value, null, 2). The null is the unused replacer slot sitting between the value and space.

You get '{"m":{},"s":{},"n":null,"i":null}'. Map and Set serialize as empty objects because their contents are internal rather than own properties, NaN and Infinity have no JSON literal so they become null, and adding a BigInt makes the call throw a TypeError.

Both parenthesis forms group a sub-pattern so quantifiers and alternation apply to the whole unit. Plain parentheses also capture, adding the matched text to the result array; (?: ... ) groups without capturing, so it never occupies a group number.

replace() with a string pattern, or with a regex that lacks the g flag, substitutes only the first occurrence. Replacing every occurrence needs replaceAll() or a /g regex; replaceAll throws a TypeError if handed a non-global regex.

Both produce the same RegExp. The literal is parsed as regex source, while the constructor takes an ordinary string, so every backslash must be doubled and a bad pattern fails at runtime. Use the constructor only for patterns assembled from runtime values.

Lookaround tests whether a sub-pattern matches at the current position without consuming characters, so the matched text excludes it. (?=x) and (?!x) look forward, (?<=x) and (?<!x) look backward, and each can be positive or negative.

A regex with the g flag carries mutable state: test and exec resume from its lastIndex property and advance it after each match, so a shared regex object alternates between matching and failing. Drop the g flag for a pure test, reset RE.lastIndex = 0, or build a fresh regex per call.

new Date(2025, 0, 31) is 31 January 2025 at local midnight. The month argument is zero-indexed (0 = January) while day-of-month starts at 1, and multi-argument construction is always read in the host's local time zone.

A Date holds only milliseconds since the epoch and carries no time zone. The plain getters project that instant into the host's local zone, the getUTC* getters project it into UTC, and getTimezoneOffset() returns UTC minus local in minutes — so it is negative east of Greenwich.

A date-only ISO string is parsed as UTC midnight; the same date with a time part but no offset is parsed as local midnight. West of Greenwich the first therefore prints as the previous calendar day, which is the classic off-by-one-day date bug.

Temporal.Instant is a fixed point on the global timeline with no zone or calendar. Temporal.PlainDateTime is a wall-clock reading with no zone, so it names no exact time. Temporal.ZonedDateTime is both together, carrying an IANA time-zone ID.

Temporal adds date units in calendar space and time units in exact-elapsed time, so across a DST shift one day may be 23 or 25 real hours. A wall-clock time that no longer exists is resolved by the disambiguation option, which defaults to compatible.

The ?? operator falls back only when the left side is null or undefined; || falls back on any falsy value. So 0, -0, NaN, the empty string and false are kept by ?? but replaced by ||.

Optional chaining short-circuits the whole remaining chain: if the value before ?. is null or undefined the entire expression evaluates to undefined, and later accesses, calls and their arguments are never evaluated. It only guards the link it is written on.

Logical assignment short-circuits the assignment itself: when the test fails no write happens at all. So x ||= y writes only if x is falsy, x &&= y only if x is truthy, x ??= y only if x is null or undefined — and setters, proxy traps and frozen-object errors are skipped entirely.

JavaScript forbids combining ?? with || or && in one expression without parentheses, so the parser rejects it. Write (a ?? b) || c or a ?? (b || c) to state the grouping explicitly; the two mean different things.

Treat it as a semantics audit, not a find-and-replace: at each site decide which values mean absent. Numeric and boolean options should use ?? so 0 and false survive; string and array options where empty genuinely means missing need an explicit check, not ??.

structuredClone performs a real deep copy: it preserves cycles and shared references and reproduces Date, RegExp, Map, Set, ArrayBuffer and typed arrays as themselves. It throws a DataCloneError for functions and symbols, and it does not preserve prototypes.

globalThis is the single standard name for the global object in every JavaScript environment. Browsers expose window, workers expose self, Node exposes global; globalThis, added in ES2020, resolves to the right one everywhere without feature sniffing.

Top-level this is the global object in a classic script, undefined in an ES module, and module.exports in a CommonJS module. Because the value depends on how the file is loaded, use globalThis when you actually want the global object.

The call throws a DataCloneError because of the callback, and it fails entirely rather than partially. The cycle would have been fine and the class instances would have survived as plain data without methods, so the fix is to separate cloneable state from behaviour and rehydrate explicitly.

Listing an ArrayBuffer in the transfer option moves its memory into the clone instead of copying it. The original buffer is left detached: its byteLength becomes 0 and it no longer holds any data, so nothing may read through it again.