JavaScript Array isArray() Method

What You’ll Learn

Array.isArray() is the correct way to ask “is this a real array?” It returns true or false, works across iframes, and rejects array-like objects. This tutorial covers syntax, five examples, pitfalls of typeof, and comparisons with instanceof.

Introduction

JavaScript values come in many shapes. Functions that expect an array need a reliable type check before calling map(), filter(), or other array methods.

Array.isArray() is the built-in answer. Do not rely on typeof (arrays are "object") or loose checks like value.length, which confuse array-like objects with real arrays.

Understanding the Array.isArray() Method

Array.isArray(value) returns true only when value is a genuine Array instance created in the current realm. It is a static method—you call it on Array, not on an instance.

It checks one level only. A nested array like [1, [2, 3]] is still an array; inner elements are tested separately if needed.

📝 Syntax

General form of the static method:

Array.isArray(value)

Parameters

• value — any JavaScript value to test.

Return value

• true if value is an Array.
• false for all other types (including null, objects, strings, array-likes).

Common patterns

• Array.isArray(items) — guard before array methods.
• if (!Array.isArray(x)) throw new TypeError(...) — validation.
• Array.isArray(x) ? x : [x] — normalize to array.
• data.filter(Array.isArray) — keep only array elements.

Examples Gallery

Open DevTools Console (F12) or use Try-it labs. Example N maps to ?tryit=N.

const numbers = [1, 2, 3];
const text = "Hello";

console.log(Array.isArray(numbers));
// true

console.log(Array.isArray(text));
// false

true
false

const arrayLike = { 0: "a", 1: "b", length: 2 };

console.log(Array.isArray(arrayLike));
// false

console.log(Array.isArray(Array.from(arrayLike)));
// true

false
true

const arr = [1, 2, 3];
const obj = { a: 1 };

console.log(typeof arr);
// "object"

console.log(typeof obj);
// "object"

console.log(Array.isArray(arr));
// true

console.log(Array.isArray(obj));
// false

object
object
true
false

function sumArray(numbers) {
  if (!Array.isArray(numbers)) {
    throw new TypeError("Input must be an array");
  }
  return numbers.reduce((sum, n) => sum + n, 0);
}

console.log(sumArray([1, 2, 3]));
// 6

6

function processItems(input) {
  if (Array.isArray(input)) {
    input.forEach((item) => console.log("Array item:", item));
  } else {
    console.log("Single value:", input);
  }
}

processItems("Hello");
// Single value: Hello

processItems(["a", "b", "c"]);
// Array item: a
// Array item: b
// Array item: c

Single value: Hello
Array item: a
Array item: b
Array item: c

🚀 Common Use Cases

• Function argument validation — require array parameters.
• API response parsing — confirm list fields are arrays.
• Normalize input — wrap single values when not an array.
• Recursive tree walks — detect nested arrays in mixed data.
• Library utilities — safe guards before map/filter.
• JSON handling — arrays vs objects after JSON.parse.

📝 Notes

• Static method—Array.isArray(x), not x.isArray().
• null and undefined return false.
• Nested arrays: outer is array; check inner elements separately if needed.
• Typed arrays (Uint8Array, etc.) return false—they are not Array instances.
• Prefer over instanceof for cross-iframe arrays.
• ES5—excellent support including IE9+.

💡 Best Practices