Adding elements to an array in JavaScript is a very simple problem. JavaScript itself provides a large number of such functions. We can use the JS-owned functions to quickly add elements to the array. This article summarizes the following methods of javascript for array addition.
The method of arr.concat(arr2) was commonly used to append an array, the example is as follows:
The code copy is as follows:
<script type="text/javascript">
var arr = new Array(3);
arr[0] = "Test array 1 is 1";
arr[1] = "Test array 1 is 2";
arr[2] = "Test array 1 is 3";
var arr2 = new Array(3);
arr2[0] = "Test array 2 is 1";
arr2[1] = "Test array 2 is 2";
arr2[2] = "Test array 2 is 3";
document.write(arr.concat(arr2)+"<br/>");
document.write(arr.concat("Your Uncle 2","Your Uncle 3")+"<br/>")
</script>
Many people have been confused about the addition and deletion of js array elements. Now I will give the following test code:
The code copy is as follows:
var arr = new Array();
arr[0] = "aaa";
arr[1] = "bbb";
arr[2] = "ccc";
//alert(arr.length);//3
arr.pop();
//alert(arr.length);//2
//alert(arr[arr.length-1]);//bbb
arr.pop();
//alert(arr[arr.length-1]);//aaa
//alert(arr.length);//1
var arr2 = new Array();
//alert(arr2.length);//0
arr2[0] = "aaa";
arr2[1] = "bbb";
//alert(arr2.length);//2
arr2.pop();
//alert(arr2.length);//1
arr2 = arr2.slice(0,arr2.length-1);
//alert(arr2.length);//0
arr2[0] = "aaa";
arr2[1] = "bbb";
arr2[2] = "ccc";
arr2 = arr2.slice(0,1);
alert(arr2.length);//1
alert(arr2[0]);//aaa
alert(arr2[1]);//undefined
shift: Delete the first item of the original array and return the value of the deleted element; if the array is empty, return undefined
var a = [1,2,3,4,5];
var b = a.shift(); //a: [2,3,4,5] b:1
unshift: add the parameter to the beginning of the original array and return the length of the array
var a = [1,2,3,4,5];
var b = a.unshift(-2,-1); //a: [-2,-1,1,2,3,4,5] b:7
Note: The test return value in IE6.0 is always undefined, and the test return value in FF2.0 is 7, so the return value of this method is unreliable. When you need to use the return value, you can use splice instead of this method.
pop: Delete the last item of the original array and return the value of the deleted element; if the array is empty, return undefined
var a = [1,2,3,4,5];
var b = a.pop(); //a: [1,2,3,4] b:5 //If you don't need to return, just call it directly
push: Add the parameter to the end of the original array and return the length of the array
var a = [1,2,3,4,5];
var b = a.push(6,7); //a: [1,2,3,4,5,6,7] b:7
concat: Returns a new array, which is composed of adding parameters to the original array.
var a = [1,2,3,4,5];
var b = a.concat(6,7); //a: [1,2,3,4,5] b: [1,2,3,4,5,6,7]
splice(start,deleteCount,val1,val2,...): DeleteCount item from the start position, and insert val1,val2,...
var a = [1,2,3,4,5];
var b = a.splice(2,2,7,8,9); //a:[1,2,7,8,9,5] b:[3,4]
var b = a.splice(0,1); //Same shift
a.splice(0,0,-2,-1); var b = a.length; //Same unshift
var b = a.splice(a.length-1,1); //Same pop
a.splice(a.length,0,6,7); var b = a.length; //Same push
reverse: Inverse the array
var a = [1,2,3,4,5];
var b = a.reverse(); //a: [5,4,3,2,1] b: [5,4,3,2,1]
sort(orderfunction): sort the array by specified parameters
var a = [1,2,3,4,5];
var b = a.sort(); //a:[1,2,3,4,5] b:[1,2,3,4,5]
slice(start,end): Returns a new array composed of items from the specified start subscript to the end subscript in the original array.
var a = [1,2,3,4,5];
var b = a.slice(2,5); //a: [1,2,3,4,5] b: [3,4,5]
join(separator): group the elements of the array into a string, with separator as the separator. If omitted, use commas as the separator by default.
var a = [1,2,3,4,5];
var b = a.join("|"); //a: [1,2,3,4,5] b: "1|2|3|4|5"
Here is another way to use array to simulate javaStringBuffer to process strings:
/**
* String processing function
*/
function StringBuffer()
{
var arr = new Array;
this.append = function(str)
{
arr[arr.length] = str;
};
this.toString = function()
{
return arr.join(""); //Ping the append array into a string
};
}
Today, I suddenly discovered that join is a good way to convert arrays into strings in the application, so I encapsulated them into objects and used:
/**
* Convert an array into a string that is split by a specific symbol
*/
function arrayToString(arr,separator)
{
if(!separator) separator = "";// If separator is null, it will be empty by default
return arr.join(separator);
}
/**
* Find the string contained in the array
*/
function arrayFindString(arr, string)
{
var str = arr.join("");
return str.indexOf(string);
}
Finally, there is a test for friends who like to play a.push.apply (a, b); when appending arrays.
a.push.apply(a, b); This self-thinking way is cool, and you don't need to write a for loop, and you haven't encountered any problems. Until today, I'm going to encounter a pit when the b I want to append is a large array.
The code copy is as follows:
a = new Array();
b = new Array(125624);
a.push.apply(a, b);
The above code throws the following exception under Mac Chrome
Uncaught RangeError: Maximum call stack size exceeded
If you change the array to b = new Array(125623); it would be nice to have a smaller element. I tested that other browsers also have large arrays to make an error, but the critical values of different browsers are still different
The suggestion given here is to be honest and practical forEach, which can not only avoid the exception problems of large arrays, but also consider the performance of forEach as the fastest.