Basic operations of js arrays (all organized by myself)_javascript skills

I have been using js for a long time, but I have never studied the array form of js. Occasionally, just use simple string.split(char). A project I worked on during this period used arrays in many places. I thought I was a master of JS but I couldn’t start with it. I’ll learn from you! hehe. After learning it, I realized that js arrays are very powerful, much more powerful than VB and C#. Let’s take a look

1. Creation of array

var arrayObj = new Array();　//创建一个数组
var arrayObj = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度
var arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);　//创建一个数组并赋值

It should be noted that although the second method creates an array and specifies the length, in fact the array is variable-length in all cases, which means that even if the length is specified to be 5, the elements can still be stored at the specified length. Otherwise, please note: the length will change accordingly.

2. Access to array elements

var testGetArrValue=arrayObj[1]; //Get the element value of the array
arrayObj[1]= "This is a new value"; //Assign new values ​​to array elements

3. Adding array elements

Code

arrayObj. push([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组结尾，并返回数组新长度
arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度
arrayObj.splice(insertPos,0,[item1[, item2[, . . . [,itemN]]]]);//将一个或多个新元素插入到数组的指定位置，插入位置的元素自动后移，返回""。

4. Deletion of array elements

arrayObj.pop(); //移除最后一个元素并返回该元素值
arrayObj.shift(); //移除最前一个元素并返回该元素值，数组中元素自动前移
arrayObj.splice(deletePos,deleteCount); //删除从指定位置deletePos开始的指定数量deleteCount的元素，数组形式返回所移除的元素

5. Interception and merging of arrays

arrayObj.slice(start, [end]); //Return a part of the array in the form of an array. Note that the element corresponding to end is not included. If end is omitted, all elements after start will be copied
arrayObj.concat([item1[, item2[, . . . [,itemN]]]]); //Concatenate multiple arrays (can also be strings, or a mixture of arrays and strings) into one array, Return the new connected array

6. Copy of array

arrayObj.slice(0); //Returns a copy array of the array. Note that it is a new array, not pointing to
arrayObj.concat(); //Return a copy array of the array. Note that it is a new array, not pointing to

7. Sorting of array elements

arrayObj.reverse(); //Reverse the elements (the first to the last, the last to the front) and return the array address
arrayObj.sort(); // Sort the array elements and return the array address

8. Stringification of array elements

arrayObj.join(separator); //Returns a string that connects each element value of the array together, separated by separator.
toLocaleString, toString, valueOf: can be regarded as special usage of join, not commonly used

2. Three attributes of array objects

1. length attribute

The Length attribute represents the length of the array, that is, the number of elements in it. Because the index of an array always starts from 0, the upper and lower limits of an array are: 0 and length-1 respectively. Unlike most other languages, the length property of JavaScript arrays is variable, which requires special attention. When the length attribute is set larger, the state of the entire array does not actually change, only the length attribute becomes larger; when the length attribute is set smaller than the original, the elements in the original array with indexes greater than or equal to length will All values ​​are lost. The following is an example demonstrating changing the length attribute:

Code

var arr=[12,23,5,3,25,98,76,54,56,76];
//定义了一个包含10个数字的数组
alert(arr.length); //显示数组的长度10
arr.length=12; //增大数组的长度
alert(arr.length); //显示数组的长度已经变为12
alert(arr[8]); //显示第9个元素的值，为56
arr.length=5; //将数组的长度减少到5，索引等于或超过5的元素被丢弃
alert(arr[8]); //显示第9个元素已经变为"undefined"
arr.length=10; //将数组长度恢复为10
alert(arr[8]); //虽然长度被恢复为10，但第9个元素却无法收回，显示"undefined"

From the above code we can clearly see the nature of the length attribute. But the length object can not only be set explicitly, it may also be modified implicitly. You can use an undeclared variable in JavaScript. Similarly, you can also use an undefined array element (referring to an element with an index greater than or equal to length). In this case, the value of the length attribute will be set to the value of the element index used. Add 1. For example, the following code:

var arr=[12,23,5,3,25,98,76,54,56,76];
alert(arr.length);
arr[15]=34;
alert(arr.length);

The code also first defines an array containing 10 numbers. It can be seen from the alert statement that its length is 10. Then the element with index 15 is used and assigned a value of 15, that is, arr[15]=34. At this time, the alert statement is used to output the length of the array, and the result is 16. Regardless, this is a surprising feature for developers accustomed to strongly typed programming. In fact, the initial length of an array created using new Array() is 0. It is the operation of undefined elements that causes the length of the array to change.
As you can see from the above introduction, the length attribute is so magical. You can use it to easily increase or decrease the capacity of an array. Therefore, an in-depth understanding of the length attribute will help to use it flexibly during the development process.

2. prototype attribute

Returns a reference to the prototype of the object type. The prototype property is common to object.
objectName.prototype
The objectName parameter is the name of the object object.

Description:
Use the prototype property to provide a basic set of functionality for an object's class. New instances of an object "inherit" the operations assigned to the object's prototype.
For array objects, the following example illustrates the use of the prototype attribute.
Add a method to the array object that returns the maximum element value in the array. To accomplish this, declare a function, add it to Array.prototype, and use it.

Code

function array_max()
{
var i,
max = this[0];
for (i = 1; i < this.length; i++)
{
if (max < this[i])
max = this[i];
}
return max;
}
Array.prototype.max = array_max;
var x = new Array(1, 2, 3, 4, 5, 6);
var y = x.max();

After this code is executed, y holds the maximum value in the array x, or say 6.

3. constructor attribute

represents a function that creates an object.
object.constructor //object is the name of the object or function.
Description: The constructor property is a member of all objects with prototype. They include all JScript native objects except Global and Math objects. The constructor property holds a reference to the function that constructs a specific object instance.
For example:
x = new String("Hi");
if (x.constructor == String) // Process (condition is true).

or
function MyFunc {
// Function body.
}

y = new MyFunc;
if (y.constructor == MyFunc) // Process (condition is true).

For arrays:
y = new Array();