what's the best way to determine whether a Javascript variable is an array, but has no other user-defined properties? 'instanceof Array' doesn't do this.
e.g.
var var1 = [10,11];
var1['key1'] = 'extraProperty';
var1 instanceof Array; //returns true
var isOnlyArray = function(o) {
if (! (Object.prototype.toString.call(o) === "[object Array]")) {
return false;
}
for (property in o) {
if (o.hasOwnProperty(property)) {
var asInt = parseInt(property, 10);
if (!(0 <= asInt && asInt < o.length)
|| String(asInt) !== property) {
return false;
}
}
}
return true;
}
This function confirms that it's an Array and that every defined property on an object is an integer index that's in the range specified by .length.
var a = [1, 2];
console.log(isOnlyArray(a)); // true
a[2] = 4;
console.log(isOnlyArray(a)); // true
a["foo"] = 5;
console.log(isOnlyArray(a)); // false
Array from another window. This is less elegant, but more reliable.
toString is assuming that the global object inherits from Object.prototype, and this is implementation dependent, for example, it won't work on any IE version (JScript) and some versions of Firefox 3.x. I would recommend you to refer to the method directly (Object.prototype.toString) or getting it in another way (e.g. ({}).toString, IIRC some implementations are optimizing this case, by not creating the new object). Cheers and +1.
if (!(0 <= asInt < o.length)), that wouldn't work like in some other languages -e.g. Python-, in Javascript, the first comparison is made (0 <= asInt) and it will yield a boolean value, that will be converted to Number for the second comparison:x < o.length the value of x will be always 0 or 1 (from the boolean conversion) you would need to do the two comparisons separately, but by knowing the limits and behavior of Array objects, I would just ensure that the property name represents a 32-bit unsigned integer.I don't think that you can verify the integrity of something that was created as an Array object. Javascript won't prohibit you from adding properties to such an object.
You could iterate through the object's properties and return false if you see one that you don't think should be in Array, but that's still no guarantee that even the normal properties haven't had their values mangled.
Just don't add properties to Arrays, then you won't have this problem. That you're asking about this kind of implies that you've done something quite wrong somewhere else in your code.
In general, you can't distinguish array and object. Object can be used as an array and vice versa. Example:
var fancyObj = {
favoriteFood: "pizza",
add: function(a, b){
return a + b;
}
};
fancyObj.add(2,3); // returns 5
fancyObj['add'](2,3); // ditto.
JSON.stringify(var1)gives you array notation, despite and without the extra property, really.