Introduction to usage examples of array Array in JS_javascript skills

new Array()
new Array(len)
new Array([item0,[item1,[item2,...]]]
Method of using array object:
var objArray=new Array ();
objArray.concact([item1[,item2[,....]]]-------------------Concatenate the parameter list to objArray Later, a new array is formed and returned, and the original array is not affected. For example: var arr=["a","b","c"];
arr.concact("d","e") ;
will return an array containing elements from "a" to "e", while arr itself is not affected.
objArray.join(separator)------------- ---Use the character specified by separator as the separator to convert the array into a string. When separator is a comma, its function is the same as toString() --------- In layman's terms, it pops the last element of the array. Combined with the push method below, it is possible to use the array as a stack. The pop method returns the value of the last element of the array and decrements the length attribute by 1, which is lost immediately after return. The last element.
objArray.push([value1[,value2[,....]]])-------------Add parameters to the end of the array. For example: [ 1,2,3, 4].push("a","b") will get [1,2,3,4,"a","b"]
objArray.reverse() will get the The elements are reversed. For example: [1,2,3].reverse() will get [3,2,1]. This operation is performed on the original array and also returns the array itself
objArray.shift ()----------Remove the first element of the array and return the value of this element. The nature of this method is very similar to the pop method, which removes the last element. >objArray.slice(start,end)---------- Returns a subset of the array object. The index starts from start (including start) and ends at end (excluding end). The original array does not Affected. For example: [1,2,3,4,5,6].slice(1,4) will get [2,3,4]. When start or end is a negative number, use them plus length. Ground value. For example: [1,2,3,4,5,6].slice(-4,-1) will get [3,4,5]. If end is less than or equal to start, an empty array will be returned.
objArray.sort(comparefn)------- Sort an array according to the size comparison function defined by comparefn. The function comparefn must accept two parameters element1 and element2. If you need element1 to be ranked before element2, you should return a negative number; if you need element1 to be ranked after element2, you should return a positive number. If the two numbers are treated equally (that is, keep the original order), returns 0. When comparefn is omitted, the elements are arranged in dictionary order. For example: for the defined comparison function cmp: function cmp(e1,e2){return e1-e2;} then [3,4,2,7].sort(cmp) will get [2,3,4,7].
objArray.splice(start,deleteCount[,item1,item2[,...]]]) This is a complex function used to complete the deletion, replacement and insertion operations of array elements. Among them, the start parameter indicates the index position to be operated, and deleteCount refers to the number of elements to be deleted from start (including the start position). If deleteCount is omitted, it means that the remaining part of the array is to be deleted from start. [,item1[,item2[,...]]] represents the optional list of elements inserted before start. For example:
var arr=[0,1,2,3,4,5,6];
arr.splice(1,1);
document.write(arr);//Display " 0, 2, 3, 4, 5, 6”
arr=[0,1,2,3,4,5,6];
arr.splice(0,0,"a","b ");
document.write(arr);//Display "a,b,0,1,2,3,4,5,6"
arr=[0,1,2,3,4 ,5,6];
arr.splice(3,2,"c","d");
document.write(arr);//Display "0,1,2,c,d, 5,6"
objArray.unshift(item1[,item2[,...]]]) ------------------- Insert the parameter list into the array beginning. Its nature is the same as the push method type, but the push method adds elements to the end of the array. For example: [1,2,3,4].unshift("a","b") will get ["a","b",1,2,3,4].

The addition and deletion of js array elements has always been confusing. Today I finally found detailed information. Give me a test code first^-^
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, undefined will be returned
var a = [1,2,3,4,5];
var b = a.shift(); //a: [2,3,4,5] b: 1

unshift: Add parameters 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 under IE6.0 is always undefined, and the test return value under FF2.0 is 7, so the return value of this method is unreliable. You can use splice when you need to use the return value. Use this method instead.

pop: Delete the last item of the original array and return the value of the deleted element; if the array is empty, it returns 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 parameters to the end of the original array , and returns 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 formed by 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,...): Delete deleteCount items from the start position and insert val1, val2,... from this position

Clear the array , just pass startIndex.

If you do not want to delete all elements, pass the deleteCount parameter again.

splice also has the function of deleting first and then adding, that is, deleting several elements first, and then adding several elements at the deleted position. The number of deleted and added elements does not have to be equal. At this time, deleteCount is also To be used.
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 as shift
a.splice(0,0,-2,-1); var b = a.length;//Same as unshift
var b = a.splice(a.length-1,1);//Same as pop
a.splice(a.length,0,6,7 ); var b = a.length; //Same as push

reverse: Reverse 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 according to the specified parameters Sort
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 between the specified start index and the end index 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): Combine the elements of the array into a string, using separator as the separator. If omitted, the default comma is used as the separator
var a = [1,2,3 ,4,5];
var b = a.join("|"); //a：[1,2,3,4,5] b："1|2|3|4|5"

Give me another method of using array to simulate javaStringBuffer to process strings:

Copy the code The code is as follows:

/**
* 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 appended array into a string
};
}

Today in the application, I suddenly discovered that join is a good way to convert an array into a string, so I encapsulated it into an object and used:

Copy code The code is as follows:

/**
*Convert the array into a string separated by specific symbols
*/
function arrayToString(arr,separator) {
if(!separator) separator = "";//If separator is null, it defaults to empty
return arr.join(separator);
}

/**
* Find the string contained in the array
* /
function arrayFindString(arr,string) {
var str = arr.join("");
return str.indexOf(string);
}