Introduction to array features in JavaScript_javascript skills

Unlike the Java language, arrays in JavaScript have three characteristics:

1. No type. The members of an array can be of any type, and the same array can also be composed of many members of different types.
2. The length is variable. The length of the array can be changed dynamically, so there is no out-of-bounds problem with array access in JavaScript.
3. Discontinuity. The positions of the members in the array can be continuous (0, 1, 2, 3...) or discontinuous. Any array has an attribute named length. When the array members are continuous, the length value is consistent with the number of array members; when the array members are discontinuous, the length value is greater than the number of array members. Compared with continuous arrays, the read and write performance of discontinuous arrays is worse.

Experiment:

Copy code The code is as follows:

var o = [42, "Sample Text", {x:88}];//JavaScript array is un-typed.
console.log(o);//[42, "Sample Text", Object {x=88}]
o[3] = 27;//JavaScript array is dynamic.
console.log(o);//[42, "Sample Text", Object {x=88}, 27]
o[5] = 99;//JavaScript array is sparse.
console.log(o);//[42, "Sample Text", Object {x=88}, 27, undefined, 99]

As you can see from the above example, for a discontinuous array, JavaScript will return undefined when the missing member is accessed. If the array is continuous but one of its members is undefined, the result of accessing the array is the same:

Copy code The code is as follows:

var a = [42, "Sample Text", {x:88}, 27, undefined, 99];
console.log(a);//[42, "Sample Text", Object {x=88}, 27, undefined, 99]

The array is discontinuous and has missing members, and the array is contiguous but has undefined members. In both cases, the result of accessing the array contents is the same. But there are still some subtle differences between the two, mainly in the access to array keys:

Copy code The code is as follows:

console.log(4 in o);//false
console.log(4 in a);//true

It can be seen that although the results obtained by accessing the content are the same in these two cases, their internal mechanisms are completely different: when the array is discontinuous, a certain member is missing, so when the member is accessed, JavaScript returns undefined; when the array is continuous, all members exist, but the values ​​of some members are special and are undefined.

As you can see from the above example, arrays in JavaScript are essentially just objects with numbers as keys, and are no different from ordinary key-value pairs. In fact, when reading and writing operations on the array, JavaScript will try to convert the parameter into a positive integer. If the conversion is successful, the array operation will be performed (the length property of the array is automatically updated). If it fails, the parameter will be converted into a character. After the string, read and write operations on ordinary objects are performed. Of course, in the implementation of the JavaScript interpreter, a lot of performance optimizations have been made for the feature of arrays that use numbers as keys. Therefore, in actual use, if the keys of the object are all numbers, then directly using the array object will get better results. Efficient results.

During the process of defining an array, JavaScript allows redundant commas and missing array members between two commas:

Copy code The code is as follows:

var x = [1,2,3,];//trailing comma will be omitted.
console.log(x.length);//3
                                   
var y = [1,,3];//member can be missed.
console.log(y);//[1, undefined, 3]
console.log(1 in y);//false
console.log(y.length);//3

For the creation of arrays, JavaScript supports four methods:

1. Use literals (such as the bracket expressions in the above examples) to directly create array objects.
2. Use the Array() constructor without passing in any parameters. In this case, an empty array is created, which has the same effect as [].
3. Use the Array() constructor and pass in a positive integer as the length of the array. In this case, JavaScript will reserve the corresponding memory space to store this array. It is worth noting that the keys of the array are not defined at this time, that is, there are no members in the array. The effect is the same as [,,,,]
4. Use the Array() constructor and pass in the members of the array.

Experiment:

Copy code The code is as follows:

var z = new Array(10);//pre-allocate memory, but no index is defined yet.
console.log(3 in z);//false

var m = new Array(42, 33, 99, "test", {k:99});
console.log(m);//[42, 33, 99, "test", Object {k=99}]

In the ECMAScript 5 standard, you can use Array.isArray() to determine whether an object is an array:

Copy code The code is as follows:

Array.isArray([]);//true
Array.isArray({});//false