Checking types reliably

Values reach your functions from many places: form fields, JSON data, libraries, tests, and your own classes. Before you use a value, you often need to ask a small question about it. For example:

• Is this really an array?
• Did someone pass null?
• Is this thrown value a real Error, or just some object?

JavaScript has no single check that answers every question. It has several checks, and each one answers a different question:

• typeof gives a quick, rough type name, such as "string" or "object".
• instanceof asks whether an object was made by a certain class.
• Array.isArray asks one thing only: is this an array?
• Object.prototype.toString reads a label that every value has. Objects can change their label.
• Error.isError asks whether a value is a real error. It is very new, so many browsers don't have it yet.

The table below runs every check on many values. Read across one row to see how one value does in every check. Read down one column to see what one check is good at.

The Error.isError column fills in after the page loads in your browser. It shows results only if your browser has this new check. Node 22 and many browsers don't have it yet.

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}

typeof is an operator. You write it before a value, and it gives back the value's type as text. You met it in the Data types lesson and again in The rest of the operators. It gives one of these answers: "string", "number", "boolean", "bigint", "symbol", "undefined", "function", or "object".

Most answers are what you expect. One is a surprise: typeof null gives "object".

In the first JavaScript engines, each value carried a small type number. Objects used one number. null happened to look like that object number. So typeof null gave "object".

Many websites came to depend on that answer, so it was never fixed. It does not mean null is an object. null has no properties at all.

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

A small helper function can give friendlier names. It checks the special cases first, then uses typeof for everything else:

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

The order matters:

• Line 2 checks for null before typeof can say "object".
• Line 3 checks for arrays, because typeof [] also says "object".
• Line 4 uses typeof for every other value.

Every object has a hidden link to another object, called its prototype. The object can borrow methods from its prototype. That prototype can link to another object, and so on. This line of links is the object's prototype chain. The next stage covers it in full. Here you only need one fact about it.

When you write new Basket(), the new object links to Basket.prototype. Then basket instanceof Basket asks one question: is Basket.prototype anywhere along basket's chain of links?

Step through this example twice. First, keep the link. Then change line 4 so it removes the link with Object.setPrototypeOf(basket, null). Before you step, guess whether the second check changes.

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 traps:

• Plain values are not objects. "x" instanceof String is false, because "x" is a plain string, not an object made by String. To check for a string, use typeof value === "string".
• Values from another realm fail. A realm is a separate JavaScript world with its own built-ins, such as its own Array and Error. An iframe (a page shown inside your page) is one example. An array made in an iframe links to the iframe's Array.prototype, not yours. So your page's instanceof Array check gives false.
• Changing the link changes the answer. You saw this on line 4. Real apps rarely do this, but it shows that instanceof only follows the links.

Array.isArray: the check to trust for arrays

Arrays are objects, so typeof [] gives "object". That doesn't tell an array apart from any other object.

[] instanceof Array is usually true in small tests, because the array and the check come from the same realm. But "usually" is not good enough when you check data you don't control.

Array.isArray(value) asks exactly one question: is this value a real array? It says true for arrays from any realm, including an iframe. It says false for plain objects that only have a 0 and a length.

So when you see typeof value === "object" or value instanceof Array used to check for an array, use Array.isArray(value) instead.

const list = { 0: "tea", length: 1 };
console.log(Array.isArray(list));
console.log(Array.isArray(["tea"]));

Line 1 makes a plain object with a 0 and a length. It looks like an array, but it has no array methods. Line 2 prints false. Line 3 checks a real array and prints true.

This matters when data comes from a form, a library, or another window. "It has numbered keys" only describes how the object looks. Array.isArray asks whether it really is an array.

Every object has a toString method. It turns the object into text. But each kind of object does this its own way:

• Arrays join their items: [1, 2].toString() gives "1,2".
• Dates write out the date.
• Your own objects can replace the method with their own.

The original toString lives on Object.prototype. It does something more useful for type checks: it reads a label. To use it on any value, add .call(value). .call runs a function and tells it which value to work on:

Object.prototype.toString.call(value)

This gives text such as [object Array], [object Null], [object Date], [object Map], and [object Promise]. The last word is the label.

An object can set its own label with Symbol.toStringTag. It is one of the well-known symbols from the Symbols lesson. Built-in objects such as Map use it, and your objects can too.

Step through the labels. Line 1 saves the original method as tag, so the later lines stay short.

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);

One more focused check is worth knowing: the check for NaN. NaN means "not a number". It is the number value you get when a math step fails, such as Number("tea").

console.log(Number.isNaN("tea"));
console.log(isNaN("tea"));
console.log(Number.isNaN(NaN));

• Line 1 asks whether the string "tea" is the value NaN. It is not, so it prints false.
• Line 2 uses the older global isNaN. It first converts "tea" to a number, which gives NaN. So it prints true.
• Line 3 checks the real NaN value and prints true.

Use Number.isNaN when you mean "is this value NaN?" Use the global isNaN only when you want that conversion, and leave a comment that says so.

Errors have the same realm problem as arrays. An error made in another iframe links to that iframe's Error.prototype, not yours. So err instanceof Error can be false, even for a real error.

Error.isError(value) is a very new check. It answers "is this a real error object?" It works across realms. It also says false for plain objects that only copy an error's name and message.

Node 22 and many browsers don't have it yet. So your code must first check that it exists, and only then call it. This is called feature detection. The helper below does it on lines 2 and 3. The playground runs the helper in your browser after the page loads.

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 every browser has it, you can fall back to the label check:

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

This fallback works because real errors keep the [object Error] label, even when they come from another realm. But Symbol.toStringTag can change a label. So the fallback is a good guess, not proof. Don't rely on it for security.

The right check depends on what your code needs to know. Here are three real jobs:

• telling plain objects apart from arrays and null
• checking that a value has what your code will use
• checking data from a server

A plain object is one made with curly brackets, like { name: "Asha" }. This helper accepts plain objects only:

function isPlainObject(value) {
  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
  const prototype = Object.getPrototypeOf(value);
  return prototype === Object.prototype || prototype === null;
}
const profile = { name: "Asha" };
console.log(isPlainObject(profile));
console.log(isPlainObject(["Asha"]));
console.log(isPlainObject(null));

• Line 2 turns away null, values that are not objects, and arrays.
• Line 3 reads the object's prototype with Object.getPrototypeOf.
• Line 4 accepts only two prototypes. One is Object.prototype, which every curly-bracket object links to. The other is null, for objects made with Object.create(null). Those have no prototype at all, and code often uses them as simple dictionaries.
• Line 6 makes a plain object. Lines 7 to 9 print true for it, false for an array, and false for null.

Often you don't need lines 3 and 4. If any object that is not null and not an array will do, line 2's checks are enough. Add the prototype check only when you really need plain objects.

function canShowName(value) {
  return typeof value === "object" && value !== null && "name" in value;
}
const user = { name: "Asha", role: "editor" };
console.log(canShowName(user));
console.log(canShowName({ role: "editor" }));

This helper does not ask which class made the value. It asks two things on line 2: is the value an object that is not null, and does it have a name? Line 5 prints true for user. Line 6 prints false for an object with no name.

This style is called duck typing, after the saying "if it walks like a duck and quacks like a duck, it is a duck." You accept a value because it has what your code will use.

function readProfile(value) {
  if (value === null || typeof value !== "object" || Array.isArray(value)) return "invalid profile";
  const prototype = Object.getPrototypeOf(value);
  if (prototype !== Object.prototype && prototype !== null) return "invalid profile";
  if (typeof value.name !== "string") return "invalid profile";
  if (typeof value.age !== "number" || !Number.isInteger(value.age)) return "invalid profile";
  return value.name + ", " + value.age;
}
const response = { name: "Asha", age: 28 };
console.log(readProfile(response));
console.log(readProfile({ name: "Asha", age: "28" }));

Data from a server can have any shape, so check it as soon as it arrives. Lines 1 to 8 define readProfile:

• Lines 2 to 4 make sure the value is a plain object.
• Line 5 checks that name is a string.
• Line 6 checks that age is a whole number. Number.isInteger is true only for whole numbers.
• Line 7 builds the text to show.

Line 10 prints Asha, 28. Line 11 prints invalid profile, because that age is the string "28", not a number. After this one check, the rest of your app can trust the shape of the data.

The table below is a quick guide. Each row starts with something you might need to know. Read across to find the check to use, and why it works.

Now sort each question under the check that answers it best.

Common misconceptions

Your first try counts, and every answer explains why. Before you pick, ask what each question really wants to know.

Key takeaways

• typeof is good for plain values, such as strings and numbers, and for functions. It gives "object" for null, which is an old mistake.
• Use value === null for null, and Array.isArray(value) for arrays.
• instanceof asks whether a class's prototype is in an object's chain of links. Other realms and changed links can change the answer.
• Object.prototype.toString.call(value) reads a useful label. Objects can change that label with Symbol.toStringTag.
• Check that Error.isError exists before you call it. The label check is a fallback, and it can be fooled.

Up next: The prototype chain. It explains the chain of links that property lookup and instanceof follow.