1.join() (array to string)

Array to string, the method only receives one parameter: the default comma separator ().

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr=[
       1,
       2,
       3,
       4];
      
     

     

      

     
     

      
	
       console.log(arr.join()); 
       //1,2,3,4
      
     

     

      

     
     

      
	
       console.log(arr.join(
       ":")); 
       //1:2:3:4
      
     

     

      

     
     

      
	
       console.log(arr); 
       //[1,2,3,4], the original array remains unchanged
      
     

     

      

     
     

      

       </script>
      
     
   

join() implements duplicate strings

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
    
       function repeatStr(str, n) {
      
     

     

      

     
     

      
        
       return 
       new 
       Array(n + 
       1).join(str);
      
     

     

      

     
     

      

           }
      
     

     

      

     
     

      
	
       console.log(repeatStr(
       "hi",
       3)); 
       //Hi, hi, hi
      
     

     

      

     
     

      
	
       console.log(repeatStr(
       "Hi",
       3)); 
       //HiHiHi
      
     

     

      

     
     

      
	
       console.log(repeatStr(
       1,
       3));    
       //111
      
     

     

      

     
     

      

       </script>
      
     
   

2.push() and pop() (array tail operation)

push(): method adds one or more elements to the end of the array and returns a new length.

pop(): method used to delete and return the last element of the array.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr=[
       1,
       2,
       3,
       4];
      
     

     

      

     
     

      
	
       //push
      
     

     

      

     
     

      
	
       var push_arr=arr.push(
       "Tom",
       "Sun");
      
     

     

      

     
     

      
	
       console.log(arr); 
       //[1,2,3,4,"Tom","Sun"];
      
     

     

      

     
     

      
	
       console.log(push_arr); 
       // 6
      
     

     

      

     
     

      
	
       //pop
      
     

     

      

     
     

      
	
       var pop_arr=arr.pop();
      
     

     

      

     
     

      
	
       console.log(arr); 
       //[1,2,3,4,"Tom"];
      
     

     

      

     
     

      
	
       console.log(pop_arr); 
       // Sun	
      
     

     

      

     
     

      

       </script>
      
     
   

3.shift() and unshift() (array header operation)

shift(): the method is used to delete the first element of the array and return the value of the first element.

unshift(): the method adds one or more elements to the beginning of the array and returns a new length.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr=[
       1,
       2,
       3,
       4];
      
     

     

      

     
     

      
	
       //shift
      
     

     

      

     
     

      
	
       var shift_arr=arr.shift();
      
     

     

      

     
     

      
	
       console.log(arr); 
       // [2, 3, 4]
      
     

     

      

     
     

      
	
       console.log(shift_arr); 
       // 1
      
     

     

      

     
     

      
	
       //unshift
      
     

     

      

     
     

      
	
       var unshift_arr=arr.unshift(
       "Tom");
      
     

     

      

     
     

      
	
       console.log(arr); 
       // ["Tom", 2, 3, 4]
      
     

     

      

     
     

      
	
       console.log(unshift_arr); 
       // 4
      
     

     

      

     
     

      

       </script>
      
     
   

4.sort() (sort)

Method is used to sort the elements of an array.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr=[
       1,
       100,
       5,
       20];
      
     

     

      

     
     

      
	
       console.log(arr.sort()); 
       // [1, 100, 20, 5]
      
     

     

      

     
     

      
	
       console.log(arr); 
       // [1, 100, 20, 5] (original array changed)	
      
     

     

      

     
     

      

       </script>
      
     
   

Please note that the above code does not sort the numbers according to the size of the number, but according to the order of character coding. To achieve this, you must use a sorting function:

Ascending order:

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr=[
       1,
       100,
       5,
       20];
      
     

     

      

     
     

      
	
       function sortNumber(a,b){
       return a - b};
      
     

     

      

     
     

      
	
       console.log(arr.sort(sortNumber)); 
       //[1, 5, 20, 100]
      
     

     

      

     
     

      
	
       console.log(arr); 
       //[1, 5, 20, 100] (original array changed)
      
     

     

      

     
     

      

       </script>
      
     
   

Descending order:

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr=[
       1,
       100,
       5,
       20];
      
     

     

      

     
     

      
	
       function sortNumber(a,b){
       return b - a};
      
     

     

      

     
     

      
	
       console.log(arr.sort(sortNumber)); 
       // [100, 20, 5, 1]
      
     

     

      

     
     

      
	
       console.log(arr); 
       // [100, 20, 5, 1] (original array changed)
      
     

     

      

     
     

      

       </script>
      
     
   

5.reverse() (reverse array)

Method is used to reverse the order of elements in an array.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr=[
       12,
       25,
       5,
       20];
      
     

     

      

     
     

      
	
       console.log(arr.reverse()); 
       // [20, 5, 25, 12]
      
     

     

      

     
     

      
	
       console.log(arr); 
       // [20, 5, 25, 12] (original array changed)
      
     

     

      

     
     

      

       </script>
      
     
   

6.concat() (connect two or more arrays)

The concat() method is used to join two or more arrays. This method does not change the existing array, but only returns a copy of the connected array. Without passing arguments to the concat() method, it simply copies the current array and returns a copy.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr=[
       1,
       2,
       3,
       4];
      
     

     

      

     
     

      
	
       var arr2=[
       11,
       12,
       13] 
      
     

     

      

     
     

      
	
       var arrCopy = arr.concat(arr2);
      
     

     

      

     
     

      
	
       console.log(arr.concat()); 
       // [1, 2, 3, 4] (copy array)
      
     

     

      

     
     

      
	
       console.log(arrCopy); 
       // [1, 2, 3, 4, 11, 12, 13]
      
     

     

      

     
     

      
	
       console.log(arr); 
       // [1, 2, 3, 4] (original array unchanged)
      
     

     

      

     
     

      

       </script>
      
     
   

What if the parameter passed in is a two-dimensional array?

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr=[
       1,
       2,
       3,
       4];
      
     

     

      

     
     

      
	
       var arr2=[
       11,[
       12,
       13]] 
      
     

     

      

     
     

      
	
       var arrCopy = arr.concat(arr2);	
      
     

     

      

     
     

      
	
       console.log(arrCopy); 
       // [1, 2, 3, 4, 11, Array(2)]
      
     

     

      

     
     

      
	
       console.log(arr); 
       // [1, 2, 3, 4] (original array unchanged)
      
     

     

      

     
     

      

       </script>
      
     
   

As can be seen from the above code, the concat method can only add each item in the incoming array to the array. If some items in the incoming array are arrays, this array item will also be added to arrCopy as an item.

7.slice() (array interception)

arr.slice(start , end);

Start: required. Specify where to start. If it is negative, it specifies the position from the end of the array. That is, - 1 refers to the last element, - 2 refers to the penultimate element, and so on.

End: optional. Specify where to end the selection. This parameter is the array subscript at the end of the array fragment. If this parameter is not specified, the segmented array contains all elements from start to the end of the array. If this parameter is negative, it specifies the elements starting from the end of the array.

Return value: returns a new array containing the elements in the arr from start to end (excluding this element).

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr = [
       1,
       4,
       6,
       8,
       12];
      
     

     

      

     
     

      
	
       var arrCopy1 = arr.slice(
       1);	
      
     

     

      

     
     

      
	
       var arrCopy2 = arr.slice(
       0,
       4);	
      
     

     

      

     
     

      
	
       var arrCopy3 = arr.slice(
       1,
       -2);
      
     

     

      

     
     

      
	
       var arrCopy4 = arr.slice(
       -5,
       4);
      
     

     

      

     
     

      
	
       var arrCopy5 = arr.slice(
       -4,
       -1)
      
     

     

      

     
     

      
	
       console.log(arrCopy1);  
       // [4, 6, 8, 12]
      
     

     

      

     
     

      
	
       console.log(arrCopy2);  
       // [1, 4, 6, 8] 
      
     

     

      

     
     

      
	
       console.log(arrCopy3);  
       // [4, 6] 
      
     

     

      

     
     

      
	
       console.log(arrCopy4);  
       // [1, 4, 6, 8]
      
     

     

      

     
     

      
	
       console.log(arrCopy5);  
       // [4, 6, 8]
      
     

     

      

     
     

      
	
       console.log(arr);  
       // [1, 4, 6, 8, 12] (original array unchanged) 
      
     

     

      

     
     

      

       </script>
      
     
   

8.splice() (array update)

The splice() method adds / removes items to / from the array, and then returns the deleted items. (this method changes the original array)

arr.splice(index , howmany , item1,.....,itemX)

index: required. Integer that specifies the position of the item to be added / deleted. Use a negative number to specify the position from the end of the array.

howmany: required. Number of items to delete. If set to 0, the item is not deleted.

item1, ..., itemX: optional. Adds a new item to the array.

Return value: an array containing deleted elements. If no elements are deleted, an empty array is returned.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr = [
       "Zhang San",
       "Li Si",
       "Wang Wu",
       "Xiao Ming",
       "Xiao Hong"];
      
     

     

      

     
     

      
	
       /**************Delete "Wang Wu"****************/
      
     

     

      

     
     

      
	
       var arrReplace1 = arr.splice(
       2,
       1);	
      
     

     

      

     
     

      
	
       console.log(arrReplace1);  
       // ["king five"] 
      
     

     

      

     
     

      
	
       console.log(arr);  
       // ["Zhang San", "Li Si", "Xiao Ming", "Xiao Hong"] (original array changed)
      
     

     

      

     
     

      
	
       //Delete multiple
      
     

     

      

     
     

      
	
       var arrReplace2 = arr.splice(
       1,
       2);	
      
     

     

      

     
     

      
	
       console.log(arrReplace2);  
       // ["Li Si", "Xiao Ming"] 
      
     

     

      

     
     

      
	
       console.log(arr);  
       // ["Zhang San", "Xiao Hong"]
      
     

     

      

     
     

      
	
       /**************Add "Xiaogang"****************/
      
     

     

      

     
     

      
	
       var arrReplace3 = arr.splice(
       1,
       0,
       "Xiao Gang");
      
     

     

      

     
     

      
	
       console.log(arrReplace3);  
       // [] (no element was deleted, so an empty array was returned)
      
     

     

      

     
     

      
	
       console.log(arr);  
       // ["Zhang San", "Xiao Gang", "Xiao Hong"]
      
     

     

      

     
     

      
	
       //Add multiple
      
     

     

      

     
     

      
	
       var arrReplace4 = arr.splice(
       3,
       0,
       "Liu Yi",
       "Chen er",
       "Zhao Liu");
      
     

     

      

     
     

      
	
       console.log(arrReplace4);  
       // []
      
     

     

      

     
     

      
	
       console.log(arr);  
       // ["Zhang San", "Xiao Gang", "Xiao Hong", "Liu Yi", "Chen Er", "Zhao Liu"]
      
     

     

      

     
     

      
	
       /**************"Wang Wu "replaces" Xiao Gang "****************/
      
     

     

      

     
     

      
	
       var arrReplace5 = arr.splice(
       1,
       1,
       "Wang Wu");
      
     

     

      

     
     

      
	
       console.log(arrReplace5);  
       // ["Xiaogang"]
      
     

     

      

     
     

      
	
       console.log(arr);  
       // ["Zhang San", "Wang Wu", "Xiao Hong", "Liu Yi", "Chen Er", "Zhao Liu"]
      
     

     

      

     
     

      
	
       //Replace multiple
      
     

     

      

     
     

      
	
       var arrReplace6 = arr.splice(
       1,
       4,
       "Li Si");
      
     

     

      

     
     

      
	
       console.log(arrReplace6);  
       // ["Wang Wu", "Xiao Hong", "Liu Yi", "Chen Er"]
      
     

     

      

     
     

      
	
       console.log(arr);  
       // ["Zhang San", "Li Si", "Zhao Liu"]
      
     

     

      

     
     

      

       </script>
      
     
   

Adding method of ES5 array:

Two index methods: indexOf() and lastIndexOf()

Both methods return the position where the item to be found first appears in the array, and - 1 if it is not found

indexOf()--------array.indexOf(item,start) (search backward from the beginning of the array (position 0))

item: required. Find the element.

Start: optional integer parameter. Specifies where to start retrieval in the array. If this parameter is omitted, the retrieval will start from array[0].

lastIndexOf()--------array.lastIndexOf(item,start)

item: required. Find the element.

Start: optional integer parameter. Specifies where to start retrieval in the array. If this parameter is omitted, the retrieval will start from {array[array.length-1].

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr = [
       1,
       4,
       7,
       10,
       7,
       18,
       7,
       26];
      
     

     

      

     
     

      
	
       console.log(arr.indexOf(
       7));        
       // 2
      
     

     

      

     
     

      
	
       console.log(arr.lastIndexOf(
       7));    
       // 6
      
     

     

      

     
     

      
	
       console.log(arr.indexOf(
       7,
       4));      
       // 4
      
     

     

      

     
     

      
	
       console.log(arr.lastIndexOf(
       7,
       2));  
       // 2
      
     

     

      

     
     

      
	
       console.log(arr.indexOf(
       5));        
       // -1		
      
     

     

      

     
     

      

       </script>
      
     
   

Five iterative methods: forEach(), map(), filter(), some(), every()

The syntax of these methods is the same, and none of them will change the original array.

forEach(): loop through the array. This method does not return a value. jquery() also provides the corresponding method, each().

Syntax: array forEach(function(currentValue , index , arr){//do something}, thisValue)

currentValue: required. Current element

Index: optional. The index value of the current element.

arr: optional. The array object to which the current element belongs.

thisValue: optional. The value passed to the function is generally "this". If this parameter is empty, "undefined" is passed to the "this" value

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var Arr = [
       1,
       4,
       7,
       10];
      
     

     

      

     
     

      

       	Arr.forEach(
       function(currentValue, index, arr){
      
     

     

      

     
     

      
		
       console.log(index+
       "--"+currentValue+
       "--"+(arr === Arr));		
      
     

     

      

     
     

      

       	})
      
     

     

      

     
     

      
	
       // Output:
      
     

     

      

     
     

      
	
       // 0--1--true
      
     

     

      

     
     

      
	
       // 1--4--true
      
     

     

      

     
     

      
	
       // 2--7--true
      
     

     

      

     
     

      
	
       // 3--10--true	
      
     

     

      

     
     

      

       </script>
      
     
   

map(): refers to "mapping". The method returns a new array. The elements in the array are the values of the original array elements after calling the function.

Syntax: array map(function(currentValue , index , arr){//do something}, thisValue)  

The map method squares each number in the array:

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
    
       var arr = [
       1,
       4,
       8,
       10];
      
     

     

      

     
     

      
    
       var arr2 = arr.map(
       function(currentValue){
      
     

     

      

     
     

      
        
       return currentValue*currentValue;
      
     

     

      

     
     

      

           });
      
     

     

      

     
     

      
    
       console.log(arr2);  
       // [1, 16, 64, 100]
      
     

     

      

     
     

      

       </script>
      
     
   

filter(): "filter" function. The method creates a new array containing all the elements of the test implemented by the provided function. Similar to the filter() method, there is a grep() method in jquery, which is also used for filtering array elements.

Syntax: array filter(function(currentValue , index , arr){//do something}, thisValue) 

The filter method filters out all elements less than 5:

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
    
       var arr = [
       1,
       4,
       6,
       8,
       10];
      
     

     

      

     
     

      
    
       var result1 = arr.filter(
       function(currentValue){
      
     

     

      

     
     

      
        
       return currentValue>
       5;
      
     

     

      

     
     

      

           });
      
     

     

      

     
     

      
    
       console.log(result1);  
       // [6, 8, 10]
      
     

     

      

     
     

      
    
       var result2 = arr.filter(
       function(currentValue){
      
     

     

      

     
     

      
        
       return currentValue>
       "5";
      
     

     

      

     
     

      

           });
      
     

     

      

     
     

      
    
       console.log(result2);  
       // [6, 8, 10]
      
     

     

      

     
     

      

       </script>
      
     
   

When we set item > 5 and item > "5" respectively, the returned results are the same. Therefore, we can see that the function supports weak equals (= =), not all (= =).

every(): judge whether each item in the array meets the conditions. true will be returned only if all items meet the conditions.

Syntax: array every(function(currentValue , index , arr){//do something}, thisValue) 

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr = [
       1,
       4,
       6,
       8,
       10];
      
     

     

      

     
     

      
	
       var result1 = arr.every(
       function(currentValue){
      
     

     

      

     
     

      
	    
       return currentValue< 
       12;
      
     

     

      

     
     

      

       	});
      
     

     

      

     
     

      
	
       console.log(result1);  
       // true
      
     

     

      

     
     

      
	
       var result2 = arr.every(
       function(currentValue){
      
     

     

      

     
     

      
	    
       return currentValue> 
       1;
      
     

     

      

     
     

      

       	});
      
     

     

      

     
     

      
	
       console.log(result2);  
       // false
      
     

     

      

     
     

      

       </script>
      
     
   

some(): judge whether there are items that meet the conditions in the array. As long as one item meets the conditions, it will return true.

Syntax: array some(function(currentValue , index , arr){//do something}, thisValue)

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr = [
       1,
       4,
       6,
       8,
       10];
      
     

     

      

     
     

      
	
       var result1 = arr.some(
       function(currentValue){
      
     

     

      

     
     

      
	    
       return currentValue> 
       10;
      
     

     

      

     
     

      

       	});
      
     

     

      

     
     

      
	
       console.log(result1);  
       // false
      
     

     

      

     
     

      
	
       var result2 = arr.some(
       function(currentValue){
      
     

     

      

     
     

      
	    
       return currentValue> 
       5;
      
     

     

      

     
     

      

       	});
      
     

     

      

     
     

      
	
       console.log(result2);  
       // true
      
     

     

      

     
     

      

       </script>
      
     
   

Two merging methods: reduce() and reduceRight()

Both methods iterate over all the items in the array and then generate a final return value. They all receive two parameters. The first parameter is the function called by each item. The function accepts four parameters: initial value, current value, index value, and current array. The function needs to return a value, which will be used as the initial value in the next iteration. The second parameter is the iterative initial value. The parameter is optional. If it is the default, the initial value is the first item of the array, which is superimposed from the first item of the array. The default parameter needs one operation less than the normal value transfer.

The reduce() method starts from the first item of the array and traverses one by one to the end. Reducereight() starts from the last item of the array and traverses forward to the first item.

reduce() syntax: arr.reduce (function (total, cur, index, ARR) {/ / do something}, initialvalue)

reduceRight() syntax: arr.reduceright (function (total, cur, index, ARR) {/ / do something}, initialvalue)

total: required. Initial value, or return value after calculation.

cur: required. Current element.

Index: optional. The index of the current element.

arr: optional. The array object to which the current element belongs.

initialValue: optional. The initial value passed to the function.

The following code implements array summation:

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       var arr = [
       1,
       2,
       3,
       4,
       5];
      
     

     

      

     
     

      
	
       var result1 = arr.reduce(
       function(total,cur,index,arr){	
      
     

     

      

     
     

      
		
       console.log(
       "total:"+total+
       ",cur:"+cur+
       ",index:"+index);
      
     

     

      

     
     

      
	    
       return total+cur;
      
     

     

      

     
     

      

       	});
      
     

     

      

     
     

      
	
       console.log(
       "result:"+result1);
      
     

     

      

     
     

      
	
       // output
      
     

     

      

     
     

      
	
       // total:1,cur:2,index:1
      
     

     

      

     
     

      
	
       // total:3,cur:3,index:2
      
     

     

      

     
     

      
	
       // total:6,cur:4,index:3
      
     

     

      

     
     

      
	
       // total:10,cur:5,index:4
      
     

     

      

     
     

      
	
       // Result: 15
      
     

     

      

     
     

      
	
       var result2 = arr.reduce(
       function(total,cur,index,arr){	
      
     

     

      

     
     

      
		
       console.log(
       "total:"+total+
       ",cur:"+cur+
       ",index:"+index);
      
     

     

      

     
     

      
	    
       return total+cur;
      
     

     

      

     
     

      

       	},
       10);
      
     

     

      

     
     

      
	
       console.log(
       "result:"+result2);
      
     

     

      

     
     

      
	
       // output
      
     

     

      

     
     

      
	
       // total:10,cur:1,index:0
      
     

     

      

     
     

      
	
       // total:11,cur:2,index:1
      
     

     

      

     
     

      
	
       // total:13,cur:3,index:2
      
     

     

      

     
     

      
	
       // total:16,cur:4,index:3
      
     

     

      

     
     

      
	
       // total:20,cur:5,index:4
      
     

     

      

     
     

      
	
       // Result: 25
      
     

     

      

     
     

      

       </script>
      
     
   

From the above code, we can see that when we do not pass the iterative initial value to the function, the initial value ＾ total is the first item of the array, and the function iterates from the second item of the array; If we pass the initial value of the iteration to the function, the function iterates from the first item of the array.

New method for ES6 array (note browser compatibility)

1.Array.from()

The method is used to convert array like objects (that is, objects with length attribute) and traversable objects into real arrays.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       let json ={
      
     

     

      

     
     

      
	    
       '0':
       'Lu',
      
     

     

      

     
     

      
	    
       '1':
       'book',
      
     

     

      

     
     

      
	    
       '2':
       'Great',
      
     

     

      

     
     

      
	    
       length:
       3
      
     

     

      

     
     

      

       	}
      
     

     

      

     
     

      
	
       let arr = 
       Array.from(json);
      
     

     

      

     
     

      
	
       console.log(arr); 
       // ["Lu", "Ben", "Wei"]	
      
     

     

      

     
     

      

       </script>
      
     
   

2.Array.of()

The method is to convert a set of values into an array. The parameters are not divided into types, but only fractional quantities. If the quantity is 0, an empty array is returned.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       let arr1 = 
       Array.of(
       1,
       2,
       3);	
      
     

     

      

     
     

      
	
       let arr2 = 
       Array.of([
       1,
       2,
       3]);
      
     

     

      

     
     

      
	
       let arr3 = 
       Array.of(
       undefined);
      
     

     

      

     
     

      
	
       let arr4 = 
       Array.of();
      
     

     

      

     
     

      
	
       console.log(arr1); 
       // [1, 2, 3]
      
     

     

      

     
     

      
	
       console.log(arr2); 
       // [[1, 2, 3]]
      
     

     

      

     
     

      
	
       console.log(arr3); 
       // [undefined]
      
     

     

      

     
     

      
	
       console.log(arr4); 
       // []
      
     

     

      

     
     

      

       </script>
      
     
   

3.find()

Method returns the value of the first element of the array that passes the test (judgment within the function). The method calls the function execution once for each element in the array. When the element in the array returns true when testing the condition, find() returns the qualified element, and the subsequent value will not call the execution function again. undefined if there are no qualified elements.

The callback function can receive three parameters, namely, the current value (currentValue), the current position (index) and the original array (arr)

Note: the find() function does not execute for empty arrays. Find () does not change the original value of the array.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       let Arr = [
       1,
       2,
       5,
       7,
       5,
       9];
      
     

     

      

     
     

      
	
       let result1 = Arr.find(
       function(currentValue,index,arr){			
      
     

     

      

     
     

      
		
       return currentValue>
       5;
      
     

     

      

     
     

      

       	});
      
     

     

      

     
     

      
	
       let result2 = Arr.find(
       function(currentValue,index,arr){			
      
     

     

      

     
     

      
		
       return currentValue>
       9;
      
     

     

      

     
     

      

       	});
      
     

     

      

     
     

      
	
       console.log(result1); 
       // 7
      
     

     

      

     
     

      
	
       console.log(result2); 
       // undefined
      
     

     

      

     
     

      

       </script>
      
     
   

The find() implementation takes out the objects in the array according to the id

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       let Arr = [
      
     

     

      

     
     

      

       		{
      
     

     

      

     
     

      
			
       id:
       1,
      
     

     

      

     
     

      
			
       name:
       "Zhang San"
      
     

     

      

     
     

      

       		},
      
     

     

      

     
     

      

       		{
      
     

     

      

     
     

      
			
       id:
       2,
      
     

     

      

     
     

      
			
       name:
       "Li Si"
      
     

     

      

     
     

      

       		}		
      
     

     

      

     
     

      

       	];
      
     

     

      

     
     

      
	
       let obj = Arr.find(
       function(currentValue,index,arr){			
      
     

     

      

     
     

      
		
       return currentValue.id===
       1;
      
     

     

      

     
     

      

       	});
      
     

     

      

     
     

      
	
       console.log(obj.name); 
       // Zhang San
      
     

     

      

     
     

      

       </script>
      
     
   

4.findIndex ()

findIndex is similar to find, but it returns the index by default. If there are no qualified elements, it returns - 1

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       let Arr = [
       1,
       2,
       5,
       7,
       5,
       9];
      
     

     

      

     
     

      
	
       let result1 = Arr.findIndex(
       function(currentValue,index,arr){			
      
     

     

      

     
     

      
		
       return currentValue>
       5;
      
     

     

      

     
     

      

       	});
      
     

     

      

     
     

      
	
       let result2 = Arr.findIndex(
       function(currentValue,index,arr){			
      
     

     

      

     
     

      
		
       return currentValue>
       9;
      
     

     

      

     
     

      

       	});
      
     

     

      

     
     

      
	
       console.log(result1); 
       // 3
      
     

     

      

     
     

      
	
       console.log(result2); 
       // -1
      
     

     

      

     
     

      

       </script>
      
     
   

5.fill()

The fill() method fills all the elements in an array from the start index to the end index with a fixed value. Index termination is not included.

Syntax: array fill(value,  start,  end)

Value: required. The value of the padding.

start: optional. start filling position. If this parameter is negative, it specifies that it starts from the end of the array.

End: optional. Stop filling position (default = array.length). If this parameter is negative, it specifies that it starts from the end of the array.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
    
       let arr = [
       1,
       2,
       3,
       4,
       5,
       6];
      
     

     

      

     
     

      

           arr.fill(
       0);  
       // [0, 0, 0, 0, 0, 0]
      
     

     

      

     
     

      

           arr.fill(
       0,
       1);  
       // [1, 0, 0, 0, 0, 0] 
      
     

     

      

     
     

      

           arr.fill(
       0,
       1,
       2);  
       // [1, 0, 3, 4, 5, 6]
      
     

     

      

     
     

      

           arr.fill(
       0,
       -1);  
       // [1, 2, 3, 4, 5, 0]
      
     

     

      

     
     

      

           arr.fill(
       0,
       1,
       -1);  
       // [1, 0, 0, 0, 0, 6]
      
     

     

      

     
     

      

       </script>
      
     
   

6. Traverse the array methods keys(), values(), and entries()

These three methods all return an ergodic object, which can be used for Of loop traversal. The only difference is that keys() traverses key names, values() traverses key values, and entries() traverses key value pairs.

keys()

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       let arr = [
       "a",
       "b",
       "c",
       "d"];
      
     

     

      

     
     

      
	
       for(
       let i 
       of arr.keys()){
      
     

     

      

     
     

      
		
       console.log(i);
      
     

     

      

     
     

      

       	}
      
     

     

      

     
     

      
    
       //Print:
      
     

     

      

     
     

      
    
       // 0
      
     

     

      

     
     

      
    
       // 1
      
     

     

      

     
     

      
    
       // 2
      
     

     

      

     
     

      
    
       // 3
      
     

     

      

     
     

      

       </script>
      
     
   

values()

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       let arr = [
       "a",
       "b",
       "c",
       "d"];
      
     

     

      

     
     

      
	
       for(
       let i 
       of arr.values()){
      
     

     

      

     
     

      
		
       console.log(i);
      
     

     

      

     
     

      

       	}
      
     

     

      

     
     

      
    
       //Print:
      
     

     

      

     
     

      
    
       // a
      
     

     

      

     
     

      
    
       // b
      
     

     

      

     
     

      
    
       // c
      
     

     

      

     
     

      
    
       // d
      
     

     

      

     
     

      

       </script>
      
     
   

entries()

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
    
       let arr = [
       "a",
       "b",
       "c",
       "d"];
      
     

     

      

     
     

      
    
       for(
       let i 
       of arr.entries()){
      
     

     

      

     
     

      
        
       console.log(i);
      
     

     

      

     
     

      

           }
      
     

     

      

     
     

      
    
       //Print:
      
     

     

      

     
     

      
    
       // [0, "a"]
      
     

     

      

     
     

      
    
       // [1, "b"]
      
     

     

      

     
     

      
    
       // [2, "c"]
      
     

     

      

     
     

      
    
       // [3, "d"]
      
     

     

      

     
     

      
    
       for(
       let [idx,item] 
       of arr.entries()){
      
     

     

      

     
     

      
        
       console.log(idx+
       ":"+item);
      
     

     

      

     
     

      

           }
      
     

     

      

     
     

      
    
       //Print:
      
     

     

      

     
     

      
    
       // 0:a
      
     

     

      

     
     

      
    
       // 1:b
      
     

     

      

     
     

      
    
       // 2:c
      
     

     

      

     
     

      
    
       // 3:d
      
     

     

      

     
     

      

       </script>
      
     
   

7.includes()

Method is used to determine whether an array contains a specified value. If yes, it returns true; otherwise, it returns false.

Syntax: arr.includes(searchElement, fromIndex)

searchElement: required. The element value to find.

fromIndex: optional. Search for searchElement starting at this index. If it is a negative value, it is from array. In ascending order Start the search with the index of length + fromIndex. The default is 0.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       let arr = [
       "a",
       "b",
       "c",
       "d"];
      
     

     

      

     
     

      
	
       let result1 = arr.includes(
       "b");
      
     

     

      

     
     

      
	
       let result2 = arr.includes(
       "b",
       2);
      
     

     

      

     
     

      
	
       let result3 = arr.includes(
       "b",
       -1);
      
     

     

      

     
     

      
	
       let result4 = arr.includes(
       "b",
       -3);
      
     

     

      

     
     

      
	
       console.log(result1);  
       // true
      
     

     

      

     
     

      
	
       console.log(result2);  
       // false
      
     

     

      

     
     

      
	
       console.log(result3);  
       // flase
      
     

     

      

     
     

      
	
       console.log(result4);  
       // true
      
     

     

      

     
     

      

       </script>
      
     
   

8.copyWithin()

Method is used to copy elements from the specified location of the array to another specified location of the array, overwriting the original members

Syntax: array copyWithin(target ,  start ,  end)

target: required. Replace data from this location.

start: optional. start reading data from this location. The default is 0. If it is negative, it indicates the reciprocal.

end: optional. Stop reading data before reaching this position. By default, it is equal to the length of the array. If it is negative, it indicates the reciprocal.

   

     

      

     
     

      

       <script>
      
     

     

      

     
     

      
	
       let arr = [
       1,
       2,
       3,
       4,
       5,
       6];
      
     

     

      

     
     

      
	
       let result1 = [
       1,
       2,
       3,
       4,
       5,
       6].copyWithin(
       0);
      
     

     

      

     
     

      
	
       let result2 = [
       1,
       2,
       3,
       4,
       5,
       6].copyWithin(
       0,
       1);
      
     

     

      

     
     

      
	
       let result3 = [
       1,
       2,
       3,
       4,
       5,
       6].copyWithin(
       1,
       3,
       5);
      
     

     

      

     
     

      
	
       let result4 = [
       1,
       2,
       3,
       4,
       5,
       6].copyWithin(
       1,
       2,
       -1);
      
     

     

      

     
     

      
	
       let result5 = [
       1,
       2,
       3,
       4,
       5,
       6].copyWithin(
       1,
       -4,
       6);
      
     

     

      

     
     

      
	
       console.log(result1);  
       // [1, 2, 3, 4, 5, 6]
      
     

     

      

     
     

      
	
       console.log(result2);  
       // [2, 3, 4, 5, 6, 6]
      
     

     

      

     
     

      
	
       console.log(result3);  
       // [1, 4, 5, 4, 5, 6]
      
     

     

      

     
     

      
	
       console.log(result4);  
       // [1, 3, 4, 5, 5, 6]
      
     

     

      

     
     

      
	
       console.log(result5);  
       // [1, 3, 4, 5, 6, 6]
      
     

     

      

     
     

      

       </script>