6

To check if an element is an array in JavaScript, I have always used Crockford's function (pg 61 of The Good Parts):

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

But if I'm not mistaken, recently some guy from Google had found a new way on how to test for a JavaScript array, but I just can't remember from where I read it and how the function went.

Can anyone point me to his solution please?


[Update]
The person from Google who apparently discovered this is called Mark Miller.

Now I've also read that from this post that his solution can easily break as well:

// native prototype overloaded, some js libraries extends them
Object.prototype.toString= function(){
  return  '[object Array]';
}

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

var a = {};
alert(isArray(a)); // returns true, expecting false;

So, I ask, is there any way that we can truly check for array validity?

6
  • Possible duplicates: stackoverflow.com/questions/1202841 stackoverflow.com/questions/1058427 Commented Nov 18, 2009 at 22:13
  • 4
    @Andreas: if you stab yourself in the eye, don't wonder why you're going blind... Commented Nov 18, 2009 at 23:00
  • ah haha; ure talking about messing with the Object.prototype ? Commented Nov 18, 2009 at 23:00
  • 1
    @Andreas: yes; extending Object.prototype is (or would be) ok as long as everyone remembers to check hasOwnProperty(), but overwriting native methods definitely is a big NO-NO; the only valid reason to do this is to fix bugs/non-standard behaviour (cough JScript cough) Commented Nov 18, 2009 at 23:13
  • I agree with you completely, but the problem is that certain libraries tend to extend the Object prototype...which will then screw up your code Commented Nov 18, 2009 at 23:16

2 Answers 2

7

I believe you are looking for

Object.prototype.toString.call(value) === "[object Array]";

This is the method that jQuery uses to check whether a passed parameter value is a function or array object. There are browser specific instances where using typeof does not yield the correct result

Sign up to request clarification or add additional context in comments.

4 Comments

FYI the second example is not a valid shorthand. jQuery creates a local toString reference that simply points to Object.prototype.toString.
Doesn't jQuery define it as a local reference to resolve the call quicker? Since all objects derive from Object, they should all have the toString function
@Russ: heh, sorry I think we're just saying the same thing. You're right, jQuery simply does var toString = Object.prototype.toString;. My point was Object.prototype.toString !== window.toString, which invalidates your statement that the second example is equivalent to the first example, that's all :) Cheers.
You could of course, define a toString function on the constructor's prototype and break the shorthand, so duly noted, will remove the shorthand :)
-1

You could do this:

t = [1,2];
// Now to check if this is an array
if (t.constructor == Array)
{
    alert('t is an array');
}
else
{
    alert('t is NOT an array');
}

Basically, variable.constructor == Array

1 Comment

That fails as well, for the same reasons I told @tyranid. Read the section 'Detecting Object and Array' at this post: karmagination.com/blog/2009/07/29/…

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.