摘要：標準用法，作用數組元素顛倒位置，傳參無返回值顛倒后的數組。，傳參指定一個字符串來分隔數組的每個元素選返回值一個所有數組元素連接的字符串標準用法的值變為的值變為作用并兩個或多個數組。

1.Array數組的方法

Mutator方法————"突變方法"會改變數組自身的值；

Accessor方法————"訪問方法"不會改變數組自身的值；

Iteration方法————"遍歷的方法" ；

2.Mutator方法

①[ ].push—作用：將一個或多個元素添加到數組的末尾，傳參：（單個或多個數組元素）；返回值：新數組的長度；

 //標準用法
 arr.push(el1, el2 ……elN)；
 //合并兩個數組
 [].push.apply(arr1, arr2)

②[].pop()，作用：刪除最后一個元素，傳參：無；返回值：刪除的元素。

//標準用法
let a = [1 ,2 ,3 ];
a.pop();//3

③[ ].unshift—作用：將一個或多個元素添加到數組的開頭，傳參：（單個或多個數組元素）；返回值：新數組的長度；

 //標準用法
 arr.unshift(el1, el2 ……elN)；

④[].shift()，作用：刪除第一個元素，傳參：無；返回值：刪除的元素。

//標準用法
let a = [1 ,2 ,3 ];
a.shift();//1

⑤[].reverse()，作用：數組元素顛倒位置，傳參：無；返回值：顛倒后的數組。

//標準用法
arr.reverse()

⑥[].splice()，作用：數組元素顛倒位置，傳參：（索引，刪除個數【選】，要添加的元素【選】）；返回值：被刪除的元素組成的一個數組。

//標準用法
array.splice(start)
array.splice(start, deleteCount) 
array.splice(start, deleteCount, item1, item2, ...)

⑦[].fill()，作用：用一個固定值填充一個數組中從起始索引到終止索引內的全部元素，傳參：（用來填充數組元素的值，起始索引【選】，終止索引【選】）；返回值：修改后的數組。

//標準用法
arr.fill(value) 
arr.fill(value, start) 
arr.fill(value, start, end)
//例子
[1, 2, 3].fill(4)            // [4, 4, 4]
[1, 2, 3].fill(4, 1)         // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2)      // [1, 4, 3]

⑧[].sort()，作用：對數組的元素進行排序，并返回數組，傳參：（指定排列順序的函數【選】）；返回值：排列后的數組。

//標準用法
arr.sort() 
arr.sort(compareFunction)
//例子
var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
return a - b;
});// [1, 2, 3, 4, 5]

3.Accessor方法

①[ ].join—作用：將數組（或一個類數組對象）的所有元素連接到一個字符串中。，傳參：（指定一個字符串來分隔數組的每個元素【選】）；返回值：一個所有數組元素連接的字符串；

//標準用法
var a = ["Wind", "Rain", "Fire"];
var myVar1 = a.join();      // myVar1的值變為"Wind,Rain,Fire"
var myVar2 = a.join(", ");  // myVar2的值變為"Wind, Rain, Fire"
 

②[ ].concat—作用：并兩個或多個數組。，傳參：（將數組和/或值連接成新數組【選】）；返回值：合并后的數組；

//標準用法
var alpha = ["a", "b", "c"];
var numeric = [1, 2, 3];
alpha.concat(numeric);
//["a", "b", "c", 1, 2, 3]
 

③[ ].slice—作用：方法返回一個從開始到結束（不包括結束）選擇的數組的一部分淺拷貝到一個新數組。，傳參：（開始索引【選】，結束索引【選】）；返回值：截去后的數組；

//標準用法
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1, 3);
//["Orange","Lemon"] 
  //類數組轉數組
function list() {
 return [].slice.call(arguments)}
var list1 = list(1, 2, 3); // [1, 2, 3]  
 

④[ ].toString—作用：返回一個字符串，表示指定的數組及其元素，傳參：（無）；返回值：轉化成的字符串；（=[].join()）

//標準用法
var monthNames = ["Jan", "Feb", "Mar", "Apr"];
var myVar = monthNames.toString(); // assigns "Jan,Feb,Mar,Apr" to myVar.
 

⑤[ ].includes—作用：判斷一個數組是否包含一個指定的值，傳參：（要查找的元素）；返回值：true或 false；

//標準用法
let a = [1, 2, 3];
a.includes(2); // true 
a.includes(4); // false  

⑥[ ].indexOf—作用：在數組中可以找到一個給定元素的第一個索引，傳參：（要查找的元素）；返回值：找不到-1，找得到索引；

var array = [2, 5, 9];
array.indexOf(2);     // 0
array.indexOf(7);     // -1
 

4.Iteration方法

①[ ].forEach—作用：每個元素執行一次提供的函數，傳參：（callback(當前元素,索引，該數組)）；返回值：無；

 //標準用法
 array.forEach(callback(currentValue, index, array){
 //do something
}, this)
  

②[ ].find—作用：返回數組中滿足提供的測試函數的第一個元素的值，傳參：（callback(當前元素,索引，該數組)）；返回值：該元素；（[].findIndex()返回索引）

 //標準用法
 array. find(callback(currentValue, index, array){
 //do something
}, this)
  

③[ ].filter—作用：創建一個新數組, 其包含通過所提供函數實現的測試的所有元素，傳參：（callback(當前元素,索引，該數組)）；返回值：通過測試的元素的集合的數組；

 //標準用法
 let arr = array. filter(callback(currentValue, index, array){
 //do something
 }, this)
  

④[ ].map—作用：創建一個新數組，其結果是該數組中的每個元素都調用一個提供的函數后返回的結果。，傳參：（callback(當前元素,索引，該數組)）；返回值：一個新數組，每個元素都是回調函數的結果；

 //標準用法
 var numbers = [1, 4, 9];
 var roots = numbers.map(Math.sqrt);
 // roots的值為[1, 2, 3], numbers的值仍為[1, 4, 9]
  

⑤[ ].every—作用：測試數組的所有元素是否都通過了指定函數的測試；傳參：（callback(當前元素,索引，該數組)）；返回值：true或false；

   //標準用法
   function isBigEnough(element, index, array) {
    return (element >= 10);}
   var passed = [12, 5, 8, 130, 44].every(isBigEnough);// passed is false
   passed = [12, 54, 18, 130, 44].every(isBigEnough);// passed is true
    

⑥[ ].some—作用：測試數組的某些元素是否都通過了指定函數的測試；傳參：（callback(當前元素,索引，該數組)）；返回值：true或false；

   //標準用法
   function isBigEnough(element, index, array) {
    return (element >= 10);}
   var passed = [1, 5, 8, 3, 4].some(isBigEnough);// passed is false
   passed = [2, 4, 18, 13, 4].some(isBigEnough);// passed is true
    

⑦[ ].reduce—作用：對累加器和數組中的每個元素（從左到右）應用一個函數，將其減少為單個值；傳參：（callback(累加器accumulator，當前元素,索引，該數組)）；返回值：函數累計處理的結果；

   //標準用法
   var total = [0, 1, 2, 3].reduce(function(sum, value) {
    return sum + value;
  }, 0);// total is 6

   var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
    return a.concat(b);}, []);
    // flattened is [0, 1, 2, 3, 4, 5]
    

⑧[ ].entries—作用：返回一個新的Array Iterator對象，該對象包含數組中每個索引的鍵/值對；傳參：（無)）；返回值：一個新的 Array 迭代器對象；

   //標準用法
   var arr = ["a", "b", "c"];
   var iterator = arr.entries();// undefined
   console.log(iterator);// Array Iterator {}
   console.log(iterator.next().value); // [0, "a"]
   console.log(iterator.next().value); // [1, "b"]
   console.log(iterator.next().value); // [2, "c"]

⑨[ ].values—作用：數組轉對象；傳參：（無)）；返回值：一個新的 Array 迭代器對象；

   //標準用法
   let arr = ["w", "y", "k", "o", "p"];
   let eArr = arr.values();// 您的瀏覽器必須支持 for..of 循環
   // 以及 let —— 將變量作用域限定在 for 循環中
  for (let letter of eArr) {
         console.log(letter);}

參考資料：https://developer.mozilla.org...