How to Check if a Variable Is an Array in JavaScript

You will learn the recommended way to test for arrays in JavaScript: Array.isArray(value). You will also see why checking constructor is fragile, how to safely handle any value, and where array checks are useful in real code.

JavaScript values have different types and structures. An array is a special kind of object designed to hold an ordered collection of values.

Use Array.isArray(value) to check whether a value is an array:

Array.isArray(value)

It returns:

• true when value is an array
• false for everything else, including ordinary objects, strings, numbers, null, and undefined

Array.isArray(["red", "blue"]); // true
Array.isArray({ 0: "red", length: 1 }); // false
Array.isArray("red"); // false

This matters because methods such as .map(), .filter(), and .push() are commonly used with arrays. Checking first lets your code validate input and avoid errors such as value.map is not a function.

Think of Array.isArray() as an official scanner at a building entrance. You hand it any value, and it answers one precise question: “Is this an array?”

Checking value.constructor === Array is like looking at a label someone attached to a box. The label may be missing or replaced. Array.isArray() checks the value's actual array identity instead of trusting a changeable property.

The standard syntax is:

Array.isArray(value)

value can be any JavaScript value.

const colors = ["red", "green", "blue"];
const user = { name: "Ada" };
const message = "Hello";

console.log(Array.isArray(colors));   // true
console.log(Array.isArray(user));     // false
console.log(Array.isArray(message));  // false

Use the result in an if statement:

const tags = ["javascript", "arrays"];

if (Array.(tags)) {
  .();
}  {
  .();
}

Consider this input-validation example:

const input = ["email", "notifications"];

if (!Array.isArray(input)) {
  console.log("Input must be an array.");
} else {
  console.log(input.join(", "));
}

Step by step:

1. input is assigned an array containing two strings.
2. Array.isArray(input) evaluates to true.
3. The ! operator reverses that result, so !true becomes false.
4. Because the if condition is false, JavaScript skips the first block.
5. JavaScript runs the else block.
6. input.join(", ") combines the values into "email, notifications".

Array checks are useful whenever code accepts data from outside its immediate control.

• API responses: Verify that a response field such as response.items is an array before rendering a list.
• Function arguments: Ensure a utility function received a list of IDs, tags, or files.
• Form data: Confirm a multi-select field contains an array before saving it.
• Configuration: Validate a configuration option such as allowedOrigins or plugins.
• Data processing: Skip, reject, or normalize unexpected values before using .map() or .filter().

Example: safely process a list returned by an API.

function getProductNames(data) {
  if (!Array.isArray(data.products)) {
    return [];
  }

  return data.products.map((product) => product.name);
}

getProductNames({ products: [{ name: "Keyboard" }] }); // ["Keyboard"]
({ :  }); 

In real projects, developers usually check arrays at boundaries: where API data, user input, configuration, or third-party library values enter the application.

A common pattern is a guard clause. It handles invalid input immediately and keeps the main logic less indented:

function calculateTotal(prices) {
  if (!Array.isArray(prices)) {
    throw new TypeError("prices must be an array");
  }

  return prices.reduce((total, price) => total + price, 0);
}

Another pattern is to use a fallback when an absent or invalid value should behave like an empty list:

function renderTasks(tasks) {
  const safeTasks = Array.isArray(tasks) ? tasks : [];

  return safeTasks.map((task) => `- ${task}`).join("\n");
}

Choose the behavior based on the contract of your code:

Using typeof

Arrays are objects in JavaScript, so typeof cannot distinguish them from ordinary objects.

const values = [1, 2, 3];

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

Avoid this:

if (typeof values === "array") {
  // This never runs.
}

Use Array.isArray(values) instead.

Using constructor === Array

This may work in simple cases, but constructor is a property that can be changed.

const values = [1, 2, 3];
values.constructor = Object;

console.log(values.constructor === ); 
.(.(values)); 

// Recommended array test
Array.isArray(value)

Array.isArray([]);          // true
Array.isArray([1, 2]);      // true
Array.isArray({});          // false
Array.isArray("text");     // false
Array.isArray(null);        // false
Array.isArray(undefined);   // false

Rules:

• Use Array.isArray() before calling array methods on uncertain input.
• An empty array ([]) is still an array.
• typeof [] is "object", not "array".
• Avoid value.constructor === Array for validation.
• An object with length is not necessarily an array.

What is the best way to check whether a variable is an array in JavaScript?

Use Array.isArray(variable). It returns true only for arrays.

Does typeof work for checking arrays?

No. typeof [] returns "object", which is also returned for ordinary objects.

Is variable.constructor === Array safe?

It is not the recommended approach. The constructor property can be changed, and reading it throws if the value is null or undefined.

Does Array.isArray(null) throw an error?

No. It safely returns false.

Is an empty array considered an array?

Yes. Array.isArray([]) returns true.

How do I check for an array of strings?

First check that the value is an array, then check its elements:

 isStringArray = .(value) && value.(
    item === 
);

• JavaScript data types — Understand primitives, objects, and why arrays are special objects.
• typeof operator — Learn what typeof can and cannot identify.
• Objects in JavaScript — Compare key-value objects with ordered arrays.
• Array methods — Methods such as map, filter, reduce, and join are usually used after array validation.
• Input validation — Array checks are one part of ensuring functions receive valid data.
• Guard clauses — Use early returns or errors to handle invalid values cleanly.
• Array.from() — Convert iterable and array-like values into real arrays when appropriate.