Checking if a Variable is an Array in JavaScript

In JavaScript, it’s often necessary to determine whether a variable holds an array or not. This can be crucial for preventing errors and ensuring that your code behaves as expected. In this tutorial, we’ll explore the different methods available to check if a variable is an array.

Using the Constructor Property

One of the most straightforward ways to check if a variable is an array is by using its constructor property. Every object in JavaScript has a constructor property that references the function used to create it. For arrays, this function is Array. Here’s how you can use it:

let myVariable = [1, 2, 3];
if (myVariable.constructor === Array) {
    console.log("My variable is an array.");
}

This method works because all arrays are objects and checking the constructor property is a relatively fast process for JavaScript engines.

Using Array.isArray()

Another way to check if a variable is an array, which is arguably more straightforward and explicit in its intention, is by using the Array.isArray() method. This method returns true if the object is an array; otherwise, it returns false.

let myVariable = [1, 2, 3];
if (Array.isArray(myVariable)) {
    console.log("My variable is an array.");
}

The Array.isArray() method was introduced in ECMAScript 5 and is supported by most modern browsers. If you need to support older browsers that do not have this method natively, you can use a polyfill or implement your own check as shown in the next section.

Using Object.prototype.toString.call()

For environments where Array.isArray() might not be available (like very old browsers), or if you want a more universal type checking approach, you can use Object.prototype.toString.call(). This method returns a string that indicates the object’s type.

let myVariable = [1, 2, 3];
if (Object.prototype.toString.call(myVariable) === '[object Array]') {
    console.log("My variable is an array.");
}

This approach can be used for checking other types as well by comparing the returned string with different expected type strings.

Using instanceof Operator

The instanceof operator checks if an object has in its prototype chain the constructor passed as the right operand. While it might seem like a viable option to check for arrays using myVariable instanceof Array, this method can fail when dealing with arrays created in different frames or windows, because each frame/window has its own global context and thus its own Array constructor.

let myVariable = [1, 2, 3];
if (myVariable instanceof Array) {
    console.log("My variable is an array.");
}

Conclusion

Each of these methods has its use cases and might be preferred depending on the specific requirements of your project, such as browser support or performance considerations. Array.isArray() offers a clear, explicit check that works well in most modern environments, while other methods provide fallbacks or more universal type checking capabilities.

When choosing a method, consider the balance between clarity (readability and maintainability), compatibility with your target browsers or environments, and any potential performance implications.