How do I check if a variable is an array in JavaScript?

Question

How do I check if a variable is an array in JavaScript?

if (variable.constructor == Array)

Geneticist

Checking for an object to be an array has some specific caveats... Peter's answer is the only one you should use. – Biotype

@Andy It seems that my answer is not the best. Maybe you should select a different answer as accepted? – Theaterintheround

Good point Peter. I hadn't realised your answer was receiving comments like this. I think I have long since begun to use the JQuery.isArray function when checking for arrays, and interestingly that is implemented differently to any other answer given here. I have marked the popular answer as correct. – Geneticist

Sorry that's wrong. I looked a little deeper and (as of version 1.6.2) JQuery still type checks using comparisons in the form.... toString.call(obj) === "[object Array]" – Geneticist

For IE8 support I would do this if ('push' in variable.__proto__), the quickest and maybe best way to check if some var is array. – Reckford

jsben.ch/#/QgYAV - a benchmark of the most common ways – Nosegay

https://mcmap.net/q/37068/-how-can-i-check-if-an-object-is-an-array-duplicate/… – Soneson

"This question has been asked before" ... NO, that question got asked AFTER this one – Vetavetch

Answer 1

There are several ways of checking if an variable is an array or not. The best solution is the one you have chosen.

variable.constructor === Array

This is the fastest method on Chrome, and most likely all other browsers. All arrays are objects, so checking the constructor property is a fast process for JavaScript engines.

If you are having issues with finding out if an objects property is an array, you must first check if the property is there.

variable.prop && variable.prop.constructor === Array

Some other ways are:

Array.isArray(variable)

Update May 23, 2019 using Chrome 75, shout out to @AnduAndrici for having me revisit this with his question This last one is, in my opinion the ugliest, and it is one of the slowest fastest. Running about 1/5 the speed as the first example. This guy is about 2-5% slower, but it's pretty hard to tell. Solid to use! Quite impressed by the outcome. Array.prototype, is actually an array. you can read more about it here https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray

variable instanceof Array

This method runs about 1/3 the speed as the first example. Still pretty solid, looks cleaner, if you're all about pretty code and not so much on performance. Note that checking for numbers does not work as variable instanceof Number always returns false. Update: instanceof now goes 2/3 the speed!

So yet another update

Object.prototype.toString.call(variable) === '[object Array]';

This guy is the slowest for trying to check for an Array. However, this is a one stop shop for any type you're looking for. However, since you're looking for an array, just use the fastest method above.

Also, I ran some test: http://jsperf.com/instanceof-array-vs-array-isarray/35 So have some fun and check it out.

Note: @EscapeNetscape has created another test as jsperf.com is down. http://jsben.ch/#/QgYAV I wanted to make sure the original link stay for whenever jsperf comes back online.

Klug

To extend the given answer another jsperf test here using feature testing (.push && .pop) which is way tha fastest and supported in all browsers (even old ones). The catch is that maybe an object has 'push' and 'pop' properties without being an array. Also note that when testing if is array with an object created (or passed) from another frame, most of the tests will fail (since the Array in given window is different than Array in frame window). Also there is a catch if an array is constructed via new Array or literaly as [..] – Archaize

Interesting, I will have to do some more browser test. Chrome 38 on centos 7 has the push && pop as 10% faster than constructor, however, chrome 39 on windows 8 has constructor as the fastest with no close comparison as constructor runs 70% faster than push && pop. I'll just wait for some more test to come in, thanks! – Klug

Note that if you're not sure if the variable is defined or if it could be null, be sure to do those checks first since those are the common values/objects that do not have a constructor. – Larkin

I was just focusing on the array portion. You can easily have variable && variable.constructor === Array to make sure that the variable isn't null or undefined. – Klug

Adicional methods: !!~variable.constructor.toString().indexOf('Array()'), variable.constructor.toString() == Array().constructor.toString() (probably will be a tiny bit slow) and Object.prototype.toString.call(variable) == '[object Array]' – Paltry

variable.constructor is faster only for checking actual arrays. When checking random objects (and in real world this will be the case as this is why you use this function) it's faster to use instanceof. jsperf.com/check-if-variable-is-array – Luscious

Using Chrome 50.0.2657.0 on Centos 7, constructor is still faster for me. Also, constructor can be used on everything except undefined and null. You can simply do variable && variable.constructor. Also to note, 5 instanceof Number does not work as expected. Instance of looks for the prototype, numbers do not have a prototype, unless you set one. Numbers do have constructors. – Klug

As another weird note, ` Object.prototype.toString.call(1) === '[object Number]';` is a thing. Javascript is quirky, so Numbers do have prototypes. Just instanceof does not use them. Which is weird because, its the sole purpose of it according to MDN... – Klug

NOTE: 'variable.constructor === Array' will throw EXCEPTION if variable is null but 'variable instanceof Array' not! – Epirogeny

if you look, i did provide an example of variable && variable.constructor === Array – Klug

The Array.isArray(variable) did not even work for me. The first one did excellent! – Brahmani

@Brahmani what browser are you using this on? – Klug

According to the JSPerf you posted, Array.isArray is the fastest, not the slowest – Baker

what browser and version are you on? For me, chrome/firefox, which I quickly tested, constructor is still the fastest, however, there was a noticeable improvement on string only arrays. The string only arrays are very fast. I will be running more tests. – Klug

As of Chrome 59 isArray() seems to be significantly faster, so much so I see no reason to not use isArray() in all situations. – Er

Some people enjoy providing additional information instead of the bare minimums :) – Klug

All your benchmarks are wrong - both because V8 (Chrome) changed JIT compilers and because your benchmarks aren't relevant. I recommend you check out mraleph's blog about performance and jsperf in particular. The JSPerf is like ICs do not exist and the morphism of a function isn't relevant to the compiler whereas in practice the performance characteristics are widely different depending on what the engine can prove. – Laundrywoman

Namely, V8 can inline the value true if type analysis proves the value is an array. This is irrelevant though since the instanceof is optimized to the same path. Amusingly the .constructor comparison is slower. The whole point of isArray is cross-realms (arrays passed between frames and contexts) anyway. – Laundrywoman

is variable.constructor === Array still the accepted answer as being the fastest/most-performant? or has variable instanceof Array or Array.isArray(variable) become more viable? -- asking as the answers/comments are quite old in certain places. Much appreciated :) – Trossachs

Just run the tests to see, only takes a moment. – Klug

@AnduAndrici Yeah, there was a good update to Array.isArray() on Chrome. The second fastest option now. Solid! – Klug

I'd like to second @AnduAndrici's question because it's no longer clear from the answer which solution here is the most efficient. – Steeplejack

its is clear @SebastianGaweda, read the answer. variable.constructor === Array If that was no longer the case, I would have updated it and provided a reason to why I had updated. – Klug

@Klug I disagree about it being clear. Your updates say that instanceof runs 2/3 the speed of the original answer. Does that mean faster? Slower? There's some ambiguity to the wording, although admittedly the context of the paragraph seems to indicate slower. I ran some benchmarks of my own by modifying the code in jsben.ch/QgYAV but those results suggested instanceof was fastest. On a related note, jsben.ch/QgYAV now links to an empty benchmark. – Steeplejack

If you're gonna edit your answer, please consider making it more readable for those who have not read it before. – Dotdotage

Javascript instanceof does not check for undefined and throws error when undefined :') would be worth mentioning – Jordon

@Klug I think now variable.constructor === Array will not work right!, we need to use variable.constructor.name == "Array" correct? – Philter

Answer 2

You could also use:

if (value instanceof Array) {
  alert('value is Array!');
} else {
  alert('Not an array');
}

This seems to me a pretty elegant solution, but to each his own.

Edit:

As of ES5 there is now also:

Array.isArray(value);

But this will break on older browsers, unless you are using polyfills (basically... IE8 or similar).

Tilla

I suggest, actually insist on sticking with this "instanceof" operator if you are not working with multiple frames. This is the right way of checking the object type. – Sicilia

The one case where this would fail is if you were trying to test for an Array or Object since Array instanceof Object == true. – Tana

If you are using jQuery to pass elements with find('code') or something similar you would want to check the variable with variable instanceof Object since it is not an instance of an Array. – Dworman

To reinforce @BYK's point, this only works with objects in the same frame. Don't rely on this if you are working with multiple frames! – Ferdelance

Doesn't work in some cases: Array.prototype instanceof Array; // false (should be true); also ({ __proto__ : Array.prototype }) instanceof Array; // true (should be false) – Pernicious

I'm not well-versed in JS internals - is the type of a prototype supposed to be the same as the type of the object? – Tilla

@BrettBender If you're still active, might you update your answer to reflect that as of ES5 we have Array.isArray? – Hyperacidity

@AndrewK see Fela Winkelmolen's answer, which has the Array.isArray method. As for this answer, it's probably not a great idea to morph an answer into a different answer via editing. – Rorrys

Or if you don't care about old browsers you can use Array.isArray(arr) – Susy

This is nice, but use variable.constructor === Array, by far the fastest method in javascript. jsperf.com/instanceof-array-vs-array-isarray – Klug

@muffin: why is it a good idea instead to let the answer stay outdated by five years? As you know, a lot of users won't read the comments under the answer (as much as we'd like them to), let alone that some of those comments are hidden under "Show more". – Unciform

@DanDascalescu You're right that it's not good to keep valuable information buried. But I think it's inappropriate to alter someone's answer to the point where it no longer remains the same answer in essence. Perhaps adding a notice/FYI line edited into the top-voted answer would be helpful in a way that does not betray the integrity of the original answer, but if that's the indicated remedy the system ought to incorporate it on the same level as voting on and accepting answers. Anyway, I no longer peruse meta: I don't remember what (my sense of) the consensus is regarding answer integrity. – Rorrys

This is correct as it will handle if value is undefined or null as well. – Aubree

@muffin: almost a decade later, I still prefer useful answers vs. historically accurate ones, and so do LLMs. – Unciform

Answer 3

In modern browsers (and some legacy browsers), you can do

Array.isArray(obj)

(Supported by Chrome 5, Firefox 4.0, IE 9, Opera 10.5 and Safari 5)

If you need to support older versions of IE, you can use es5-shim to polyfill Array.isArray; or add the following

# only implement if no native implementation is available
if (typeof Array.isArray === 'undefined') {
  Array.isArray = function(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
  }
};

If you use jQuery you can use jQuery.isArray(obj) or $.isArray(obj). If you use underscore you can use _.isArray(obj)

If you don't need to detect arrays created in different frames you can also just use instanceof

obj instanceof Array

---

Note: the arguments keyword that can be used to access the argument of a function isn't an Array, even though it (usually) behaves like one:

var func = function() {
  console.log(arguments)        // [1, 2, 3]
  console.log(arguments.length) // 3
  console.log(Array.isArray(arguments)) // false !!!
  console.log(arguments.slice)  // undefined (Array.prototype methods not available)
  console.log([3,4,5].slice)    // function slice() { [native code] } 
}
func(1, 2, 3)

Preposition

This is probably the best most modern approach. I've seen it along with the polyfill on MDN so that means Mozilla trusts it developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… – Bilestone

Aren't you missing prototype there? Seems it should be Object.prototype.toString.call. – Belomancy

we can also determine if the objects has the methods that are existing in array like push, splice, etc – Aback

Answer 4

There are multiple solutions with all their own quirks. This page gives a good overview. One possible solution is:

function isArray(o) {
  return Object.prototype.toString.call(o) === '[object Array]'; 
}

Theaterintheround

If you read carefully, it says this method is needed when you are working with mult-frame documents which, is not recommended. This method can easly borke on a little change in the "toString" function. – Sicilia

Therefor the link is given so that Brett can check them out and see in which case his function has to work – Theaterintheround

See my answer below. I recommend Peter Smit's way. – Elvinaelvira

This method is recommended by Mozilla. – Mirandamire

Answer 5

I noticed someone mentioned jQuery, but I didn't know there was an isArray() function. It turns out it was added in version 1.3.

jQuery implements it as Peter suggests:

isArray: function( obj ) {
    return toString.call(obj) === "[object Array]";
},

Having put a lot of faith in jQuery already (especially their techniques for cross-browser compatibility) I will either upgrade to version 1.3 and use their function (providing that upgrading doesn’t cause too many problems) or use this suggested method directly in my code.

Many thanks for the suggestions.

Geneticist

See this article for a good discussion on the topic. The conclusion is to use this solution. – Aludel

This gives me the error SCRIPT65535 in IE10. – Wenonawenonah

Answer 6

This is an old question but having the same problem i found a very elegant solution that i want to share.

Adding a prototype to Array makes it very simple

Array.prototype.isArray = true;

Now once if you have an object you want to test to see if its an array all you need is to check for the new property

var box = doSomething();

if (box.isArray) {
    // do something
}

isArray is only available if its an array

Abdomen

this sounds so cool to me! this could be native. btw it works even when a array was created before the prototyping? – Archbishop

@Vitimtk A prototype acts as a fallback for the actual object, so this should work even if the array in question already existed. It won't work before the source line is processed, of course. – Sheply

Assuming no one does Object.prototype.isArray = true;! :( – Bushmaster

Note that in ES5 Array.isArray is a method (e.g., Array.isArray([1,2,3]) === true) so @Bushmaster wasn't being a troll. I would avoid following this answer as it will break code in some modern browsers. – Devilment

@Devilment your example is correct. However ErikE it is not related, Array != [1,2,3] . So you can still do [1,2,3].isArray === true with my solution – Abdomen

@Abdomen and you can do {}.isArray === true with my "solution", which was the whole point... – Bushmaster

Modifying the prototype of Data Types is a bad practice in my opinion – Liverpudlian

@Liverpudlian what about Array.prototype["com.my.unique.name"].isArray ;) – Transmittal

Answer 7

Via Crockford:

function typeOf(value) {
    var s = typeof value;
    if (s === 'object') {
        if (value) {
            if (value instanceof Array) {
                s = 'array';
            }
        } else {
            s = 'null';
        }
    }
    return s;
}

The main failing Crockford mentions is an inability to correctly determine arrays that were created in a different context, e.g., window. That page has a much more sophisticated version if this is insufficient.

Sadi

Answer 8

If you're only dealing with EcmaScript 5 and above then you can use the built in Array.isArray function

e.g.,

Array.isArray([])    // true
Array.isArray("foo") // false
Array.isArray({})    // false

Devilment

Answer 9

I personally like Peter's suggestion: https://mcmap.net/q/37067/-how-do-i-check-if-a-variable-is-an-array-in-javascript (for ECMAScript 3. For ECMAScript 5, use Array.isArray())

Comments on the post indicate, however, that if toString() is changed at all, that way of checking an array will fail. If you really want to be specific and make sure toString() has not been changed, and there are no problems with the objects class attribute ([object Array] is the class attribute of an object that is an array), then I recommend doing something like this:

//see if toString returns proper class attributes of objects that are arrays
//returns -1 if it fails test
//returns true if it passes test and it's an array
//returns false if it passes test and it's not an array
function is_array(o)
{
    // make sure an array has a class attribute of [object Array]
    var check_class = Object.prototype.toString.call([]);
    if(check_class === '[object Array]')
    {
        // test passed, now check
        return Object.prototype.toString.call(o) === '[object Array]';
    }
    else
    {
        // may want to change return value to something more desirable
        return -1; 
    }
}

Note that in JavaScript The Definitive Guide 6th edition, 7.10, it says Array.isArray() is implemented using Object.prototype.toString.call() in ECMAScript 5. Also note that if you're going to worry about toString()'s implementation changing, you should also worry about every other built in method changing too. Why use push()? Someone can change it! Such an approach is silly. The above check is an offered solution to those worried about toString() changing, but I believe the check is unnecessary.

Elvinaelvira

Good call on the ECMAScript 5 standard. Sure you can't guarantee the browser supports it but this should be the first way to check in new code. – Illaudable

I'll start by saying that this is a bit over my head. However, would a test like this be more robust?: return Object.prototype.toString.call(o) === Object.prototype.toString.call([]); – Eastward

Answer 10

When I posted this question the version of JQuery that I was using didn't include an isArray function. If it had have I would have probably just used it trusting that implementation to be the best browser independant way to perform this particular type check.

Since JQuery now does offer this function, I would always use it...

$.isArray(obj);

(as of version 1.6.2) It is still implemented using comparisons on strings in the form

toString.call(obj) === "[object Array]"

Geneticist

Answer 11

Thought I would add another option for those who might already be using the Underscore.js library in their script. Underscore.js has an isArray() function (see http://underscorejs.org/#isArray).

_.isArray(object) 

Returns true if object is an Array.

Bornie

The underscore js implementation uses the native Array.isArray if available, otherwise it uses the toString method. – Aylmer

The same function is present in Lodash – Cauda

Answer 12

In Crockford's JavaScript The Good Parts, there is a function to check if the given argument is an array:

var is_array = function (value) {
    return value &&
        typeof value === 'object' &&
        typeof value.length === 'number' &&
        typeof value.splice === 'function' &&
        !(value.propertyIsEnumerable('length'));
};

He explains:

First, we ask if the value is truthy. We do this to reject null and other falsy values. Second, we ask if the typeof value is 'object'. This will be true for objects, arrays, and (weirdly) null. Third, we ask if the value has a length property that is a number. This will always be true for arrays, but usually not for objects. Fourth, we ask if the value contains a splice method. This again will be true for all arrays. Finally, we ask if the length property is enumerable (will length be produced by a for in loop?). That will be false for all arrays. This is the most reliable test for arrayness that I have found. It is unfortunate that it is so complicated.

Raasch

And that was just the good parts. Imagine when "JavaScript The Bad Parts" gets published... – Fluoroscope

Answer 13

If you are using Angular, you can use the angular.isArray() function

var myArray = [];
angular.isArray(myArray); // returns true

var myObj = {};
angular.isArray(myObj); //returns false

http://docs.angularjs.org/api/ng/function/angular.isArray

Festival

You can also use non Angular specific, but only IE9+ and all standards browsers: <pre><code> Array.isArray(myArray); //returns true Array.isArray(myObj); //returns false </code> </pre> – Midge

Answer 14

The universal solution is below:

Object.prototype.toString.call(obj)=='[object Array]'

Starting from ECMAScript 5, a formal solution is :

Array.isArray(arr)

Also, for old JavaScript libs, you can find below solution although it's not accurate enough:

var is_array = function (value) {
    return value &&
    typeof value === 'object' &&
    typeof value.length === 'number' &&
    typeof value.splice === 'function' &&
    !(value.propertyIsEnumerable('length'));
};

The solutions are from http://www.pixelstech.net/topic/85-How-to-check-whether-an-object-is-an-array-or-not-in-JavaScript

Plugugly

Answer 15

For those who code-golf, an unreliable test with fewest characters:

function isArray(a) {
  return a.map;
}

This is commonly used when traversing/flattening a hierarchy:

function golf(a) {
  return a.map?[].concat.apply([],a.map(golf)):a;
}

input: [1,2,[3,4,[5],6],[7,[8,[9]]]]
output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Generalissimo

Answer 16

code referred from https://github.com/miksago/Evan.js/blob/master/src/evan.js

  var isArray = Array.isArray || function(obj) {
    return !!(obj && obj.concat && obj.unshift && !obj.callee);};

Gynarchy

Why do you test both concat and unshift, wouldn't suffice to test for unshift? – Fanning

The more methods we check that Array has the move likely it really is an array. Other objects might have concat or unshift but less likely to have both. – Aylmer

Answer 17

I was using this line of code:

if (variable.push) {
   // variable is array, since AMAIK only arrays have push() method.
}

Euromarket

This is not a good solution at all. With this "solution" any object with a property push that is truthy will be considered an Array. – Pechora

Answer 18

From w3schools:

function isArray(myArray) {
    return myArray.constructor.toString().indexOf("Array") > -1;
}

Justitia

Answer 19

Here is an answer that works without fail both in old browsers and across frames. It takes the recommended Array.isArray() static method of EcmaScript 5+ and the old recommended way before ES5 and combines them so that you have a working function in both new and old JS versions:

isArray = Array.isArray || function(value) {
    return Object.prototype.toString.call(value)=="[object Array]";
}

isArray([]);//true

Of course Array.isArray() is more than 10 years old now. So you might not need to support browsers older than that. However you shouldn't underestimate the number of old browsers that are still out there.

Finish

Answer 20

I liked the Brian answer:

function is_array(o){
    // make sure an array has a class attribute of [object Array]
    var check_class = Object.prototype.toString.call([]);
    if(check_class === '[object Array]')    {
        // test passed, now check
        return Object.prototype.toString.call(o) === '[object Array]';
    } else{
        // may want to change return value to something more desirable
        return -1; 
    }
}

but you could just do like this:

return Object.prototype.toString.call(o) === Object.prototype.toString.call([]);

Cattier

Answer 21

I have created this little bit of code, which can return true types.

I am not sure about performance yet, but it's an attempt to properly identify the typeof.

https://github.com/valtido/better-typeOf also blogged a little about it here http://www.jqui.net/jquery/better-typeof-than-the-javascript-native-typeof/

it works, similar to the current typeof.

var user = [1,2,3]
typeOf(user); //[object Array]

It think it may need a bit of fine tuning, and take into account things, I have not come across or test it properly. so further improvements are welcomed, whether it's performance wise, or incorrectly re-porting of typeOf.

Botch

Answer 22

I think using myObj.constructor==Object and myArray.constructor==Array is the best way. Its almost 20x faster than using toString(). If you extend objects with your own constructors and want those creations to be considered "objects" as well than this doesn't work, but otherwise its way faster. typeof is just as fast as the constructor method but typeof []=='object' returns true which will often be undesirable. http://jsperf.com/constructor-vs-tostring

one thing to note is that null.constructor will throw an error so if you might be checking for null values you will have to first do if(testThing!==null){}

Helles

Answer 23

I tried most of the solutions here. But none of them worked. Then I came up with a simple solution. Hope it will help someone & save their time.

if(variable.constructor != undefined && variable.constructor.length > 0) {
        /// IT IS AN ARRAY
} else {
       /// IT IS NOT AN ARRAY
}

Teapot

Answer 24

 if(elem.length == undefined){
    // is not an array
 }else{
    // is an array
 } 

Raccoon

Answer 25

Since the .length property is special for arrays in javascript you can simply say

obj.length === +obj.length // true if obj is an array

Underscorejs and several other libraries use this short and simple trick.

Jhvh

Would you mind explaining how that works? Mainly, what does the '+' do? – Geneticist

This is good, but it is also true when the object is a function or a string as well as any other object with property length of type number. Why? Well, the unary + operator actually casts a variable as a number. So basically they are checking if obj.length is a number. [object Object] has no property length it is undefined so when you cast undefined as a number it becomes NaN the above check comes out as false. So it returns true if the object property length is a number, which in the case of arrays, strings, and functions it would be true. Underscore has to be doing more than just this. – Bilestone

Answer 26

Something I just came up with:

if (item.length) //This is an array else //not an array

Beverleebeverley

var item = 'this_is_not_an_array'; – Schou

That's a bad solution! A string has also a length. – Culet

Actually a string is an array of characters so in essence this does work – Sandbox

@PatrickNijhuis - string is a primitive type in javascript, whereas array is an object. In common language you're correct - a string is an array of characters - but in javascript, this assertion is wrong. It's an important distinction, and the reason why this is a bad answer. – Lodmilla

No, a zero-length array is still an array. – Nonresistance

you can put typeof item == 'object' and the answer can be acceptable – Ween

more importantly: an empty array will fail this test because 0 is falsy – Tumid