JavaScript determines whether an object is an array method summary

In development, we often need to determine whether an object is of array type

1.typeof operator. For several types of objects such as Function, String, Number, Undefined, etc., it is fully capable. , but for Array

var arr=new Array("1","2","3","4","5"); 
alert(typeof(arr));

you will receive an object answer, which is a bit disappointing.

2.instanceof operator, the instanceof operator in JavaScript will return a Boolean Value indicating whether the object is an instance of a specific class.
Usage: result = object instanceof class, still the array just now, try it again, well, it returns true successfully.

var arrayStr=new Array("1","2","3","4","5"); 
alert(arrayStr instanceof Array);

Small summary: It seems that the questions we discussed today have been answered, but In fact, shuttling between multiple frames will cause big problems.

Code

var iframe = document.createElement('iframe'); 
document.body.appendChild(iframe); 
xArray = window.frames[window.frames.length-1].Array; 
var arr = new xArray("1","2","3","4","5");//这个写法IE大哥下是不支持的，FF下才有 
alert(arr instanceof Array); // false 
alert(arr.constructor === Array); // false

The return result is two False, which is disappointing.

ECMA-262 wrote
Object.prototype.toString( ) When the toString method is called, the following steps are taken:
1. Get the [[Class]] property of this object .
2. Compute a string value by concatenating the three strings “[object “, Result (1), and “]”.
3. Return Result (2)

The above specification definition The behavior of Object.prototype.toString: first, obtain an internal property [[Class]] of the object, and then return a string similar to "[object Array]" as the result based on this property (you should have read the ECMA standard As we all know, [[]] is used to represent attributes used internally in the language and not directly accessible from the outside, called "internal attributes"). Using this method, combined with call, we can obtain the internal attributes [[Class]] of any object, and then convert the type detection into string comparison to achieve our purpose. Let’s first take a look at the description of Array in the ECMA standard:

ECMA-262 writes
new Array([ item0[, item1 [,…]]])
The [[Class ]] property of the newly constructed object is set to “Array”.
So taking advantage of this, the third method appears.
function isArray(obj) {
return Object.prototype.toString.call(obj) === '[object Array]';
} call changes the this reference of toString to the object to be detected and returns The string representation of this object is then compared to see if this string is '[object Array]' to determine whether it is an instance of Array. Maybe you want to ask, why not o.toString() directly? Well, although Array inherits from Object, it will also have a toString method, but this method may be rewritten and fail to meet our requirements, and Object.prototype is the butt of a tiger, and few people dare to touch it, so It can guarantee its "purity" to a certain extent:)
Unlike the previous solutions, this method solves the problem of cross-frame object construction very well. After testing, the compatibility of major browsers is also very good, so you can rest assured use. The good news is that many frameworks, such as jQuery, Base2, etc., plan to use this method to implement certain types of special objects, such as arrays, regular expressions, etc., without having to write them ourselves.

In addition, Ext3 has also been changed to this way of writing

isArray : function(v){ 
return toString.apply(v) === '[object Array]'; 
}

The above is the detailed content of JavaScript determines whether an object is an array method summary. For more information, please follow other related articles on the PHP Chinese website!