js syntax learning to determine whether an object is an array_javascript skills

1. How to determine a real array

The simplest way to declare an array in JavaScript is:
var a = [];
The most direct way to determine whether it is an array is:

Copy code The code is as follows:

a instanceof Array //true
a .constructor == Array //true

This involves an instanceof syntax. instanceof is a cloud operator. Like "-*/", its syntax is as follows:
result = obj intanceof class
It is used to determine whether an object is an instance of a certain class, and the operation result returns true or false. The definition of class in JavaScript is initialized through the constructor, so the right operator class of instanceof syntax must be an instance of Function, that is, class instanceof Function must be true, and if the right operator is not Function when using instanceof, it will throw A TypeError exception occurs. All objects are instances of Object, so instanceof Object returns true for any object. Although we say that objects are initialized through constructors, instanceof does not check whether the object is constructed by the function, but whether it is inherited by the prototype of the constructor. The following example can illustrate this problem:

Copy code The code is as follows:

function Range(low, high) {
this.low = low;
this.high = high;
}
Range.prototype.constructor == Range; //true
Range.prototype = {
include: function(x){ return (x >= this.low && x exclude: function(x){ return (x this.high); }
}
var r = new Range(0, 100);
r instanceof Range; //false
r instanceof Object; //true
Range.prototype.constructor == Objecct; // true

Although r is constructed through new Range, r is not an instance of Range. This is the problem. The Range.prototype assignment statement overrides the default constructor and does not assign a value to prototype. Previously, Range.prototype.constructor was Range, but after assignment, it became Object. This is easy to understand, because

Copy code The code is as follows :

Range.prototype = {
include: function(x){ return (x >= this.low && x exclude : function(x){ return (x this.high); }
}

is actually equivalent to:

Copy code The code is as follows:

Range.prototype = new Object({
include: function(x){ return ( x >= this.low && x exclude: function(x){ return (x this.high); }
});

So Range.prototype.constructor == Object, then the instance created through new Range is of course an instance of Object.
It is more straightforward to read the official explanation:
The instanceof operator does not actually check whether r was initialized by the Range constructor. It checks whether it inherits from Range.prototype.
There is also a function typeof in JavaScript that has A function similar to instanceof, but it returns specific basic data types: number, string, function, object, undefined, boolean. There are only these six types. Anything outside the scope of these six types returns object, that is to say typeof( []) returns object, not array.
Another syntax involved is constructor, constructor returns the constructor of the object:

Copy code The code is as follows:

var a = [];
a.constructor; //Array

The constructor is the initialization function of an object. It is called using new. If the object is an Array, then its constructor should be Array. This is not necessarily true for classes written by yourself, because the constructor in the prototype may be changed.

2. How to judge pseudo arrays

There is a pseudo array in JavaScript, which can be traversed using a traversal method similar to Array. There is a length attribute to get the length of an element. You can use [] Subscript to get the specified element. This kind of object is called a pseudo array. The object in JQuery is a typical pseudo array, as shown below:

So the key to judge whether it is a pseudo array is to judge Whether there is a length attribute and whether there is a basic array operation function splice, the following is the judgment method:

Copy code The code is as follows:

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

Here propertyIsEnumerable is used to determine whether the length attribute is available To enumerate, in fact, the native String object also has an effect similar to Array, but we cannot treat it as an Array object, so we need to judge typeof value == "object" here, because typeof is a String object and returns a string.