Possible Duplicate:
How to detect if a variable is an array
I have a simple question:
How do I detect if a parameter passed to my javascript function is an array? I don't believe that I can test:
if (typeof paramThatCouldBeArray == 'array')
So is it possible?
How would I do it?
Thanks in advance.
if (param instanceof Array)
...
Edit. As of 2016, there is a ready-built method that catches more corner cases, Array.isArray, used as follows:
if (Array.isArray(param))
...
!!param.shift would be faster in terms of execution speed. jsperf.com/instanceof-vs-method-detect
This is the approach jQuery 1.4.2 uses:
var toString = param.prototype.toString;
var isArray = function(obj) {
return toString.call(obj) === "[object Array]";
}
toString comparison may seem strange but it is the accepted way to deal with cross-frame environments.
toString based on param, and then I call isArray()? What do I pass as obj? Where is the bottom line of this answer?
I found this here:
function isArray(obj) {
return obj.constructor == Array;
}
also this one
function isArray(obj) {
return (obj.constructor.toString().indexOf(”Array”) != -1);
}
obj.constructor.toString() returns function Array() { [native code] }, making this solution work for that environment.You can test the constructor property:
if (param.constructor == Array) {
...
}
Though this will include objects that have an array prototype,
function Stack() {
}
Stack.prototype = [];
unless they also define constructor:
Stack.prototype.constructor = Stack;
or:
function Stack() {
this.constructor = Stack;
}
Some days ago I was building a simple type detection function, maybe its useful for you:
Usage:
//...
if (typeString(obj) == 'array') {
//..
}
Implementation:
function typeString(o) {
if (typeof o != 'object')
return typeof o;
if (o === null)
return "null";
//object, array, function, date, regexp, string, number, boolean, error
var internalClass = Object.prototype.toString.call(o)
.match(/\[object\s(\w+)\]/)[1];
return internalClass.toLowerCase();
}
The second variant of this function is more strict, because it returns only object types described in the ECMAScript specification (possible output values: "object", "undefined", "null", and "function", "array", "date", "regexp", "string", "number", "boolean" "error", using the [[Class]] internal property).
Actually, you don't necessarily want to check that an object is an array. You should duck type it and the only thing you want that object to implement is the length property. After this you can transform it into an array:
var arrayLike = {
length : 3,
0: "foo"
};
// transform object to array
var array = Array.prototype.slice.call(arrayLike);
JSON.stringify(array); // ["foo", null, null]
Array.prototype.slice.call(object) will transform into an array every object that exposes a length property. In the case of strings for example:
var array = Array.prototype.slice.call("123");
JSON.stringify(array); // ["1", "2", "3"]
Well, this technique it's not quite working on IE6 (I don't know about later versions), but it's easy to create a small utility function to transform objects in arrays.
console.log(). It intrigues me because if you pass it an array, it iterates over the whole array and prints it out. While if you just pass it a single string, it just logs that. How does it do this?Array.toString.console.logis a native function, and thus has access to info not accessible to a JS script.