Error Handling

An Error carries name (the type, e.g. 'Error'), message (the human-readable text passed to the constructor), and a non-standard but widely supported stack string showing the call stack. Built-in subtypes inherit from Error and set their own name: TypeError, RangeError, SyntaxError, ReferenceError, plus URIError and EvalError.

try wraps code that might throw. If it throws, control jumps to catch, which receives the thrown value as a binding. finally runs afterward whether or not an error occurred, even after a return, so it is used for cleanup. Since ES2019 the catch binding is optional: catch {} is valid when you ignore the error.

'use strict' is a string directive at the top of a script or function that opts that scope into strict mode. It makes the engine reject sloppy patterns: assigning to an undeclared variable throws instead of creating a global, duplicate parameter names are errors, and this is undefined in a plain function call. ES modules and class bodies are always strict, so the directive is needed only in legacy scripts.

A rejected promise can be handled with .catch(handler) chained after .then. With async/await, wrap the await in try/catch, since a rejection turns into a thrown error at the await point. If neither is present the rejection is unhandled: the browser fires a global unhandledrejection event, and Node logs a warning. try/catch cannot catch a rejection you never await.

throw expr immediately stops the current function and starts unwinding the stack looking for a catch. You can throw ANY value — a string, number, or object — but you should throw an Error instance, because only those carry a message and stack for diagnostics. Inside a catch, throw err rethrows the same error to let an outer handler deal with it.

Write class MyError extends Error and call super(message) in its constructor, then set this.name = 'MyError' so the type shows correctly. Instances pass both instanceof MyError and instanceof Error, letting handlers branch by type. The ES2022 cause option — new Error('msg', { cause: original }) — attaches the underlying error as err.cause, preserving the original when you wrap and rethrow.

When a function throws and has no local catch, the engine unwinds the stack: it abandons that function and each caller in turn, looking for the nearest enclosing try/catch. The first matching catch up the chain handles it; code after each abandoned call is skipped. If no handler is found at all, the error reaches the top and becomes an uncaught exception. So you catch where you can meaningfully recover, not necessarily at the throw site.

finally runs after the try/catch completes, on every path — normal exit, a return, or an uncaught throw — which makes it ideal for cleanup. But a return or throw inside finally overrides whatever the try or catch was about to return or throw: the pending value is discarded and the finally result wins. So putting control flow in finally can silently swallow errors.

Strict mode promotes several quiet sloppy-mode behaviours into errors: assigning to an undeclared variable throws a ReferenceError instead of creating an implicit global; writing to a read-only or non-writable property throws a TypeError rather than failing silently; and delete of a non-configurable property throws. It also sets this to undefined in a plain function call, so accidental globals via this are caught.

A try/catch only guards the synchronous call stack active when it runs. The setTimeout callback fires later on a fresh stack via the event loop, long after the try block returned, so its throw has no enclosing handler and becomes uncaught. Promises fix this: a throw inside a then/async body rejects the promise, catchable with .catch or await in try/catch. With Promise.all, the first rejection rejects the whole combinator immediately.

error.cause lets you wrap a low-level error in a domain-specific one while keeping the original — handlers can walk the cause chain to find the root failure. AggregateError bundles several errors into one (its .errors array), as Promise.any does when every input rejects. As a last resort, global handlers — window.onerror and the unhandledrejection event in browsers, or process.on('uncaughtException') in Node — catch what escaped all try/catch.

Strict mode forbids implicit globals, throws on writes to read-only or non-existent-target properties, bans duplicate parameter names and with, makes this undefined in plain calls, and reserves words like implements and interface. Crucially, ES modules and class bodies are strict automatically — the directive is never needed there. So a frozen object's property assignment throws a TypeError inside a module, whereas sloppy scripts would fail silently.