What is the difference between TypeError and ReferenceError?

A ReferenceError fires when you access a variable that does not exist in scope, such as using an undeclared name. A TypeError fires when a value exists but is the wrong type for the operation, such as calling a non-function or reading a property of null or undefined.

When is a RangeError thrown?

When a numeric value is outside its allowed set: an invalid array length, a number whose precision argument is out of range (toFixed, toPrecision), or exceeding the maximum call stack size from deep recursion. The message usually names the offending bound.

Can I catch a SyntaxError at runtime?

Only for code parsed at runtime — JSON.parse, eval, new Function or dynamic import of malformed source throw a catchable SyntaxError. A syntax error in a statically loaded script is a parse error that prevents the whole script from running and cannot be caught with try/catch.

What is AggregateError?

AggregateError wraps several errors in one object, exposed on its errors array. It is thrown by Promise.any when every promise rejects, letting you inspect all rejection reasons at once rather than just the first.

How should I create custom errors?

Extend the closest built-in class — usually Error — set this.name in the constructor, and call super(message). Custom subclasses keep instanceof working and let consumers branch on your specific type alongside the built-ins.

JavaScript Error Types Reference

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

Know which error you caught

JavaScript has a small set of built-in Error subtypes, each thrown by specific operations. Recognising the subtype tells you the class of bug instantly. This reference lists every standard error type, what throws it, a typical message and how to catch it with instanceof.

How it works

Every built-in error inherits from Error and carries name, message and a stack. The engine throws the most specific subtype for the failure, which you can branch on:

try {
  null.foo;            // TypeError: Cannot read properties of null
} catch (e) {
  if (e instanceof TypeError) handleType(e);
  else if (e instanceof RangeError) handleRange(e);
  else throw e;        // re-throw anything you do not handle
}

Because all subtypes extend Error, e instanceof Error is always true — order your checks from most specific to least, and re-throw what you cannot handle.

Tips and notes

instanceof can fail across realms (iframes, worker boundaries) where each has its own Error constructor — check e.name as a fallback in that case.
SyntaxError from static source is uncatchable; only runtime-parsed code (JSON.parse, eval, new Function) throws a catchable one.
Use Error.cause (new Error(msg, { cause })) to chain a lower-level error.
Custom errors should extend Error, call super(message) and set this.name.
A “Maximum call stack size exceeded” message is a RangeError, usually from unbounded recursion.