摘要：標準用法，作用數(shù)組元素顛倒位置，傳參無返回值顛倒后的數(shù)組。，傳參指定一個字符串來分隔數(shù)組的每個元素選返回值一個所有數(shù)組元素連接的字符串標準用法的值變?yōu)榈闹底優(yōu)樽饔貌蓚€或多個數(shù)組。

1.Array數(shù)組的方法

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

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

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

2.Mutator方法

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

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

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

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

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

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

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

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

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

//標準用法
arr.reverse()

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

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

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

//標準用法
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()，作用：對數(shù)組的元素進行排序，并返回數(shù)組，傳參：（指定排列順序的函數(shù)【選】）；返回值：排列后的數(shù)組。

//標準用法
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—作用：將數(shù)組（或一個類數(shù)組對象）的所有元素連接到一個字符串中。，傳參：（指定一個字符串來分隔數(shù)組的每個元素【選】）；返回值：一個所有數(shù)組元素連接的字符串；

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

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

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

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

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

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

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

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

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

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

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

4.Iteration方法

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

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

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

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

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

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

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

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

⑤[ ].every—作用：測試數(shù)組的所有元素是否都通過了指定函數(shù)的測試；傳參：（callback(當前元素,索引，該數(shù)組)）；返回值：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—作用：測試數(shù)組的某些元素是否都通過了指定函數(shù)的測試；傳參：（callback(當前元素,索引，該數(shù)組)）；返回值：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—作用：對累加器和數(shù)組中的每個元素（從左到右）應(yīng)用一個函數(shù)，將其減少為單個值；傳參：（callback(累加器accumulator，當前元素,索引，該數(shù)組)）；返回值：函數(shù)累計處理的結(jié)果；

   //標準用法
   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對象，該對象包含數(shù)組中每個索引的鍵/值對；傳參：（無)）；返回值：一個新的 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—作用：數(shù)組轉(zhuǎn)對象；傳參：（無)）；返回值：一個新的 Array 迭代器對象；

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

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