Suggest an edit

Improve this article

Refine the answer for “Checking whether a value is an array”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

**To check that a value is an array, use `Array.isArray(value)`: it is the modern and most reliable approach, and it works even for arrays that come from another execution context.** The other techniques (`instanceof`, `Object.prototype.toString.call()`, `typeof`) either have limitations or fail to tell an array from a plain object.

## Theory

### TL;DR

- `Array.isArray(value)` is the recommended check; it works everywhere and across contexts.
- `value instanceof Array` works, but depends on the context: an array from an iframe has a different `Array.prototype`.
- `Object.prototype.toString.call(value)` returns `"[object Array]"`, universal but verbose.
- `typeof value` is always `"object"` for an array, so it is useless as a check.
- An array is an object, so any "is it an object?" test also matches `{}` and `null`.

### Quick example

```javascript
const value = [1, 2, 3];

console.log(Array.isArray(value));                  // true
console.log(value instanceof Array);                // true
console.log(Object.prototype.toString.call(value)); // "[object Array]"
console.log(typeof value);                          // "object"
```

The first three checks answer the question; the fourth does not.

### Array.isArray, the modern and reliable way

```javascript
Array.isArray([1, 2, 3]); // true
Array.isArray('text');    // false
Array.isArray({});        // false
```

Why this one:

- It works in every modern browser and in Node.js.
- It identifies arrays correctly even from **other contexts**, for example from an iframe, a Web Worker or a separate Node.js context.
- It does not depend on the prototype: the method inspects an internal slot of the value, not the `__proto__` chain.
- It is the **recommended** way to check.

### instanceof Array, old but working

```javascript
[1, 2, 3] instanceof Array; // true
'abc' instanceof Array;     // false
```

There is a caveat, though:

- If the array was created in **another window or frame**, the result may be **wrong**, because every context has its own `Array` constructor and its own `Array.prototype`.

```javascript
// The problem in practice:
const foreignArray = new window.frames[0].Array(1, 2, 3);

console.log(foreignArray instanceof Array); // false
console.log(Array.isArray(foreignArray));   // true
```

One more detail: `instanceof` can be fooled through `Symbol.hasInstance` or by swapping the prototype, while `Array.isArray()` is immune to that.

### Checking with Object.prototype.toString.call()

This approach is universal for any type, which is why libraries often use it.

```javascript
Object.prototype.toString.call([]);   // "[object Array]"
Object.prototype.toString.call({});   // "[object Object]"
Object.prototype.toString.call('hi'); // "[object String]"
```

It is also independent of the execution context, but it returns a string you have to compare by hand, so the code ends up longer than `Array.isArray()`.

### Why not typeof

```javascript
typeof []; // "object"
```

`typeof` does not fit, because an array is an **object** and the result is always `"object"`. The same string comes back for `{}`, `null`, `new Date()` and `new Map()`, so the check tells you nothing useful about arrays.

### Comparing the methods

| Method | Returns for an array | Reliability | Comment |
| --- | --- | --- | --- |
| `Array.isArray(value)` | `true` | Highest | The best option |
| `value instanceof Array` | `true` | Medium | Depends on the execution context |
| `Object.prototype.toString.call(value)` | `"[object Array]"` | High | Universal, but verbose |
| `typeof value` | `"object"` | None | Does not distinguish arrays from other objects |

Conclusion: always use `Array.isArray(value)`, it is the most accurate and the shortest check.

### Common mistakes

- **Testing for an array with `typeof value === 'object'`.** The condition is also true for `{}`, `null`, `Date` and `Map`.
- **Forgetting `null`.** `typeof null` is `"object"` as well, so any "is it an object" test has to rule out `null` separately.
- **Relying on `instanceof` in code with iframes, Workers or several contexts.** There a genuine array gives you `false`.
- **Treating array-likes as arrays.** `arguments`, `NodeList` and any object with a `length` field are not arrays: `Array.isArray()` returns `false` for them. Use `Array.from(value)` or `[...value]` to get a real array.
- **Checking `value.constructor === Array`.** The `constructor` property is easy to overwrite, and the code throws on `null` and `undefined`.

Markdown · drag & drop images · ⌘B / ⌘I shortcuts658 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.