Checking types reliably

JavaScript lets values travel far: from form fields, JSON, libraries, iframes, tests, and your own classes. By the time a value reaches your function, you often need to ask a small question before touching it: is this really an array? Did someone pass null? Is this thrown value an Error or just a random object?

The trick is that JavaScript does not have one perfect type-check button. It has several inspectors, and each answers a different question. typeof is a fast glance. instanceof checks a family tree. Array.isArray is a specialist. The Object.prototype.toString label reader is useful but can be customized. Error.isError is the new error specialist, but it is not everywhere yet.

Start with a real matrix. Read across one row to compare checks for a single value. Read down one column to see what a check is good at. The Error.isError column is feature-detected in your browser after mount, because this new API is missing in Node 22 and in many browsers.

1const values = [null, [], new Date(), new Error("boom")];2for (const value of values) {3  console.log(typeof value);4  console.log(value instanceof Error);5  console.log(Array.isArray(value));6  console.log(Object.prototype.toString.call(value));7}

You met the typeof table in Data types and saw the operator again in The rest of the operators. Most of its answers are handy: "string", "number", "boolean", "bigint", "symbol", "undefined", "function", or "object". The historic surprise is typeof null.

In early engines, values were represented with small type tags. Object values used one tag, and the null pointer ended up looking like that object tag. The exact engine details are old history, but the result became web-compatible behavior: typeof null still returns "object". It does not mean null has properties or behaves like an object.

1const value = null;Run2const quickCheck = typeof value;3const exactCheck = value === null;4const type = getType(value);5console.log(quickCheck, exactCheck, type);

A small helper can make display labels friendlier without pretending JavaScript changed its rules:

function getType(value) {
  if (value === null) return "null";
  if (Array.isArray(value)) return "array";
  return typeof value;
}

The order is the lesson: check null before raw typeof, and check arrays before calling every object an object.

For this lesson, the precise mental model is one sentence: object instanceof Constructor asks whether Constructor.prototype is somewhere in the object’s prototype chain. The prototype chain itself is the next stage’s topic; here, you only need that one relationship.

Step through this example twice. First keep the chain. Then switch line 4 so the object’s prototype is replaced with null, and predict whether the second check can change.

1class Basket {}Run2const basket = new Basket();3const before = basket instanceof Basket;4// keep Basket.prototype in the chain5const after = basket instanceof Basket;6console.log(before, after);

instanceof has three practical pitfalls:

• Primitives are not wrapper objects: "x" instanceof String is false. Use typeof value === "string" for string primitives.
• Cross-realm values have different constructors. An array or error from an iframe can fail your page’s instanceof Array or instanceof Error check.
• Prototype changes affect the result. That is uncommon in everyday application code, but it proves what the operator reads.

Array.isArray: the trusted array inspector

Arrays are objects, so typeof [] returns "object". They are often created by the same realm as your code, so [] instanceof Array usually returns true in quick experiments. But “usually” is not a reliable API boundary.

Use Array.isArray(value) when the real question is “is this a JavaScript Array?” It recognizes arrays from other realms, including iframe-like environments, and it rejects plain objects that merely have 0 and length properties.

The common review comment is simple: if you see typeof value === "object" or value instanceof Array guarding array methods, ask for Array.isArray(value) instead.

Every object inherits a toString method, but calling a value’s own toString is not consistent: arrays join their items, dates format dates, and custom objects can override the method. The classic label reader is the original method, borrowed directly:

Object.prototype.toString.call(value)

That call returns labels such as [object Array], [object Null], [object Date], [object Map], and [object Promise]. The Symbols lesson previewed well-known symbols; here you see one in action. Symbol.toStringTag lets built-ins and your own objects customize the label.

1const tag = Object.prototype.toString;Run2const arrayTag = tag.call([]);3const nullTag = tag.call(null);4const mapTag = tag.call(new Map());5const custom = { [Symbol.toStringTag]: "Custom" };6const customTag = tag.call(custom);7console.log(arrayTag, nullTag, mapTag, customTag);

Error detection has the same cross-realm problem as arrays. An error created in another iframe or VM context inherits from that realm’s Error.prototype, not yours. That means err instanceof Error can be false even for a genuine error.

Error.isError(value) is a very recent addition designed to answer “is this really an Error object?” more reliably, including across realms and against objects that merely fake name and message. It is not in Node 22 and is missing in many browsers, so client code must feature-detect it before calling it.

1function isErrorReliable(value) {2  if (typeof Error.isError === "function") {3    return Error.isError(value);4  }5  return Object.prototype.toString.call(value) === "[object Error]";6}

Until the API is broadly available, a common fallback is:

function isErrorFallback(value) {
  return Object.prototype.toString.call(value) === "[object Error]";
}

That fallback is useful because real cross-realm errors commonly keep the [object Error] label. But it is limited: labels can be customized with Symbol.toStringTag, so do not treat it as an unfakeable security boundary.

In real code, the right check follows from the job. A validator, a parser, and an error reporter do not need the same answer. This table is the everyday cheat sheet.

Now sort each situation by the check that most directly answers it.

Common misconceptions

Your first try counts, but every answer explains the reasoning. Look for the question being asked before picking the operator.

Key takeaways

• typeof is best for primitive labels and functions; it famously returns "object" for null.
• Use value === null for null and Array.isArray(value) for arrays.
• instanceof asks whether a constructor’s prototype is in an object’s prototype chain, so realms and prototype changes matter.
• Object.prototype.toString.call(value) reads useful labels, but Symbol.toStringTag means labels can be customized.
• Feature-detect Error.isError. Use a tag fallback only with its limits clearly understood.

Up next: The prototype chain, where the family tree behind property lookup and instanceof gets its full explanation.