摘要：因為轉換為字符串后，在前面還可以接受一個函數作為參數，根據函數的返回值進行排序。函數的返回值將作為新數組中的每一項的值。該方法接收一個函數作為參數，對數組中的每一項運行該函數，該方法沒有返回值。

   var color = new Array("red", "green");
   console.log(Array.isArray(color));   //true

該方法會輸出每一項，并以","連接，實際上該方法會調用數組中每一項的toString()方法，然后拼接得到的每一項的字符串。

 var color = new Array("red", "green");
 console.log(color.toString());   // red,green
 alert(color);            // red,green
 console.log(color);            // ["red","green"]

該方法會輸出每一項，并以","連接，實際上該方法會調用數組中每一項的toLocaleString()方法，然后拼接得到的每一項的字符串。一般都會返回與toString()相同的值

 var color = new Array("red", "green");
 console.log(color.toLocaleString());   // red,green

該方法輸出整個數組的字符串形式

var color = new Array("red", "green");
 console.log(color.valueOf());   // ["red","green"]

該方法接收一個字符串，然后以該字符串為間隔，將數組中的每一項拼接起來

var color = new Array("red", "green");
 console.log(color.join("&&"));   // red&&green

棧是一種LIFO("LAST-In-First-Out"后進先出)的數據結構。
有兩個方法，push()和pop().

push()接受一個或者多個參數，將它們添加到數組末尾處，返回添加后數組的長度

pop()則從數組中移除最后一項，并返回該項的值。

隊列是一種FIFO("First-In-First-Out"先進先出)的數據結構。
有兩個方法，unshift()和shift().

unshift()與push()類似，只不過是在數組的最前面添加一項或多項

var color = new Array("red", "green");
color.unshift("blue","yellow");
console.log(color);            // ["blue", "yellow", "red", "green"]

shift()與pop()類似，是返回數組的最前面一項

有兩種排序方法，reverse()和sort()。

reverse()方法會反轉數組項的順序。

sort()默認按照升序重新排列數組，而順序的決定是由每一項轉換為字符串后進行比較的。

var values = [0, 1, 5, 10, 15];
values.sort();
console.log(values)   //   [0, 1, 10, 15, 5], 因為轉換為字符串后，10在5前面

sort()還可以接受一個函數作為參數，根據函數的返回值進行排序。這個函數接受兩個值作為參數，排序原則如下：
參數1在參數2前面，返回負數，參數1在參數2后面，返回正數，兩個參數相等，則返回0.

// 先創建一個簡單的比較函數，該函數接受兩個值做參數,本函數按照升序排列
function compare(value1, value2){
    if(value1 < value2){
      return -1;
  }else if(value1 > value2){
      return 1;
  }else {
      return 0;
  }
}
// 然后將該函數傳入sort()方法中進行比較
var values = [0, 5, 1, 15, 10];
values.sort(compare);
console.log(values);          // [0, 1, 5, 10, 15]

sort()內部是根據冒泡法排序的，不斷比較兩個數的大小。

該方法可以接收一個或多個參數，并新建一個當前數組的副本，將參數拼接到該副本末尾，然后返回該副本數組。
參數主要有兩種類型:

參數是數組，則將數組中的每一項添加到副本數組的末尾

參數不是數組，則直接將其添加到副本數組的末尾

該方法基于當前數組創建一個新的數組，接收一個或者兩個參數，用于指定返回項的起始和結束位置。

當值傳入一個參數時，返回從參數指定位置開始到數組末尾的所有項

當傳入兩個參數時，返回起始和結束位置之間的的但不包括結束位置的項。

兩個參數均可以接收負數,會以數組的長度值加上該負數，然后計算需要返回的項。

該方法可以增加，減少或修改數組中的一項或多項。該方法接收一個或多個參數，先從指定位置刪除項，然后添加任意數量的項。
該方法始終會返回一個數組，數組中包含被刪除的返回項。

參數1指定需要刪除的項的起始位置

參數2指定需要刪除的項的數量

參數3-參數n指定需要向數組中添加的項

所以根據傳入參數的數量，有以下情況：

不傳入參數，則不對數組做任何改變

var array = [1,2,3,4];
console.log(array.splice());   // []
console.log(array);            // [1,2,3,4]

傳入一個數值參數，則從數組中刪除指定位置和數組末尾之間的所有項

 var array = [1,2,3,4];
 console.log(array.splice(2));   // [3,4]
 console.log(array);        // [1,2]

傳入兩個數值參數，則刪除數組中從指定位置開始的指定數量的項

 var array = [1,2,3,4];
 console.log(array.splice(2,1));    // [3]
 console.log(array);        // [1,2,4]

傳入三個或三個以上的參數，則先刪除指定位置開始的指定數量的項，然后在該位置添加其他參數所指示的項

 var array = [1,2,3,4,5,6];
 console.log(array.splice(2,1,"red","green"));    // [3]
 console.log(array);            // [1, 2, "red", "green", 4, 5, 6]

copyWithin()方法在數組內部將一部分復制到另一部分，而不改變數組的大小，然后返回修改后的數組。該方法接收一個至三個參數。參數含義如下：

第一個參數是一個索引值，被復制的序列將放到以該索引為起始的位置上。為必需參數。

第二個參數代表將要被復制的部分的起始位置。非必需參數，默認為0。

第三個參數代表將要被復制的部分的結束位置，不包括結束位置。非必需參數，默認為array.length-1

以上三個參數都接收負值，會自動加上數組的長度值，轉換為正值。看一些例子吧。

[11, 22, 33, 44, 55].copyWithin(-2);    //  [11, 22, 33, 11, 22]

上面代碼復制到的索引位置是 5-2=3,由于后兩個參數沒有，所以復制的值是[11,22,33,44,55],但是由于該方法不改變數組的大小，所以僅僅是將11和22復制到44和55的位置。

[11, 22, 33, 44, 55].copyWithin(0, 3); //  [44, 55, 33, 44, 55]

上面的代碼復制到的索引位置是 0，復制區域開始的索引位置是3,第三個參數沒有，所以會一直復制直到末尾，復制的值是[44,55], 覆蓋了11和22

[11, 22, 33, 44, 55].copyWithin(1, 3, 4);// [11, 44, 33, 44, 55]

上面的代碼復制到的索引位置是1，復制區域開始的索引位置是3,第三個參數是4，所以只會復制位置3的值44，覆蓋了22

該方法在指定位置處填充一個固定的值。方法接收三個參數:

param1，指定填充的值。必需參數。

param2, 指定填充開始的位置。非必需參數，默認為0

param3, 指定填充結束的位置，但不包括結束的位置。默認為數組的長度值。

[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]

數組有兩個位置方法indexOf()和lastIndexOf()。兩個方法都接收一個或兩個參數，第一個參數指定要查找的項，第二個參數是可選的，表示查找開始的位置。兩個方法的區別是indexOf()從前往后開始查找，返回指定項第一次出現的位置，lastIndexOf()從后往前開始查找，返回指定項第一次出現的位置。若沒有查找到指定項，則兩個方法均返回-1。

傳入一個參數

var array = ["H", "E", "L", "L", "O"];
console.log(array.indexOf("L"));       //      2
console.log(array.lastIndexOf("L"));       //  3

傳入兩個參數

var array = ["H", "E", "L", "L", "O"];
console.log(array.indexOf("L", 3));   // 3 ,忽略了array[2]
console.log(array.lastIndexOf("L", 2));   // 2 忽略了array[3]

有兩個需要注意的事項，

數組中的項和傳入參數作比較時，用的是===全等號，即必須嚴格相等

lastIndexOf()返回的索引值是基于正序的索引值，而非基于倒序的索引值

var array = ["H", "E", "L", "L", "O"];
console.log(array.lastIndexOf("O"));     // 返回4，而非0

有兩個歸并數組的方法reduce()和reduceRight()。這兩個方法都會迭代數組中的所有項，然后構建一個返回值，其中reduce()從數組的第一項開始，遍歷到最后，reduceRight()從最后一項開始，遍歷到第一項。
這兩個方法都接收兩個參數: 第一個參數是在每一項上調用的函數，第二個參數是可選的，作為歸并基礎的初始值。
作為第一個參數的函數接收4個參數: 前一個值，當前值，當前項的索引和該數組對象。這個函數返回的值，將作為下一次迭代操作中函數的第一個參數。函數的第二個參數是數組的下一項。
第一次迭代發生在數組的第二項上，函數的第一個值是數組的第一項，第二個參數是數組的第二項。

傳入一個參數

function add(prev, curv, index, array){
    return prev + curv;
}
var values = [1, 2, 3, 4, 5];
var sum = values.reduce(add);
console.log(sum);         //15

上面的代碼中，第一次迭代中，傳入add()中的參數如下:prev = 1, curv = 2,index = 1,array = values,第一次迭代后，add()函數返回值是1+2=3。
第二次迭代中，傳入add()中的參數如下:prev = 3，curv = 3,index = 1,array = values,第二次迭代后，add()函數返回值是3+3=6。依次向后迭代...
reduceRight()則是從最后一項開始往前迭代。

傳入兩個參數
傳入兩個參數時，第二個參數將作為歸并基礎的初始值。也就是說，傳入該參數后，用該參數加上后面最終迭代得到的值。

function add(prev, curv, index, array){
   return prev + curv;
}
var values = [1, 2, 3, 4, 5];
var sum = values.reduce(add, 10);
console.log(sum);         // 25,  在迭代得到的值上面加上了10

該方法基于一個類數組的對象或可迭代的對象，創建一個新的數組實例。該方法接收一至三個參數，各個參數如下：

參數1是一個類數組對象或可迭代對象，方法基于該對象創建數組。函數的返回值將作為新數組中的每一項的值。必需的參數。

參數2是一個函數，數組的每一項都會調用該函數。非必需參數。

參數3指定在參數2中，this所代表的對象。非必需參數。

類數組對象是具有length屬性并含有被編上索引的元素的對象，如NodeList對象。
可迭代對象是可以獲得其中的元素的對象，如Map和Set

var str = "hello";
Array.from(str, x => x + x);      // ["hh", "ee", "ll", "ll", "oo"]

上面的代碼中接收一個字符串為第一個參數，接收箭頭函數作為第二個參數。在箭頭函數中，對每一項做了復制操作，然后返回得到的值，作為數組的每一項。

該方法接收一系列參數，并以這些參數為項，創建一個數組，并返回該數組。

var arra = Array.of("red", "green", "blue");
console.log(arra);         //  ["red", "green", "blue"]

該方法與構造函數Array()類似，但有一點不同。當接收到只有一個數值類型的參數時，Array()會創建一個數值參數指定的長度的數組，而Array.of()會將該數值作為數組中的項添加進數組。

var arra1 = new Array(7);
console.log(arra1);     //  [undefined × 7]
var arra2 = Array.of(7);
console.log(arra2);     //  [7]

該方法接收一個函數作為參數，對數組中的每一項運行該函數，若對每一項，指定函數都返回true，則最終every()方法返回true。該方法還接收一個可選的第二個參數，指定在運行函數時，函數中this所代表的對象。

var num = [1,2,3];
console.log(num.every( value => {
    if(value > 0){return true;}
    return false;
}));  // true，因為每一項都大于0
console.log(num.every( value => {
    if(value > 1){return true;}
    return false;
})); //false，因為1-1=0，轉換為布爾值是false

該方法與every()對應，every()是所有項均返回true，最終才返回true，some()是只要有至少一個返回true,該方法就會返回true.

var num = [1,2,3];
console.log(num.some( value => {
    if(value > 1){return true;}
    return false;
}));  // true，因為至少有一項大于1
console.log(num.some( value => {
    if(value > 3){return true;}
    return false;
})); //false，都不大于3

該方法接收一個函數作為參數，對數組中的每一項運行該函數，若對某一項，指定函數返回true，則將該項添加到一個新建的數組中，最后返回該數組。該方法還接收一個可選的第二個參數，指定在運行函數時，函數中this所代表的對象。

    var num = [1,2,3];
    console.log(num.filter( value => {
   if(value > 0){return true;}
   return false;
    }));  // [1,2,3]
    console.log(num.filter( value => {
   if(value > 1){return true;}
   return false;
    })); // [2, 3]

該方法接收一個函數作為參數，對數組中的每一項運行該函數，該方法沒有返回值。作用于for循環類似。
該方法還接收一個可選的第二個參數，指定在運行函數時，函數中this所代表的對象。

該方法接收一個函數作為參數，對數組中的每一項運行該函數，返回由該函數的返回值組成的數組。該方法還接收一個可選的第二個參數，指定在運行函數時，函數中this所代表的對象。

var num = [1,2,3];
console.log(num.map( value => { return value * value; }));     // [1, 4, 9]

該方法接受一個函數作為參數，對數組中的每一項運行該函數，直到某一次運行后返回true，此時，該方法將返回該項的值。若所有項的運行結果都是fase,最終將返回undefined。所以該方法并不一定遍歷數組中所有項。該方法還接收一個可選的第二個參數，指定在運行函數時，函數中this所代表的對象。

 var num = [1,2,3];
console.log(num.find( value => {
    if(value === 2){return true;}
    return false;
}));  // 2

看如下代碼

var inventory = [
    {name: "apples", quantity: 2},
    {name: "bananas", quantity: 0},
    {name: "cherries", quantity: 5}
];

function findCherries(fruit) {
    return fruit.name === "cherries";
}

console.log(inventory.find(findCherries));
// { name: "cherries", quantity: 5 }

該方法與find()類似，只不過當找到符合條件的項時，會返回該項的索引值。

var num = [1,2,3];
  console.log(num.findIndex( value => {
    if(value === 2){return true;}
    return false;
}));  // 1

注意:以上方法中，接收的作為參數的函數，都可以接受三個參數，分別是數組每一項的當前值，當前索引值，以及調用方法的數組本身.

var num = [1,2,3];
num.forEach( (value, index, array) => {
    console.log("數組為->"+array + ":");
    console.log(index + "->" + value);
});
// 數組為->1,2,3: 0->1
// 數組為->1,2,3: 1->2
// 數組為->1,2,3: 2->3

entries()方法返回一個新建的數組迭代對象，對象中包含了每一項的key/value組成的數組。看代碼

  var a = ["a", "b", "c"];
  var iterator = a.entries();
  for(let e of iterator){
     console.log(e);
  }
  // [0, "a"]
  // [1, "b"]
  // [2, "c"]

該方法返回一個可迭代對象，其中包含了數組中每一項的索引值

 var arr = ["a", "b", "c"];
 var iterator = arr.keys();

 console.log(iterator.next()); // { value: 0, done: false }
 console.log(iterator.next()); // { value: 1, done: false }
 console.log(iterator.next()); // { value: 2, done: false }
 console.log(iterator.next()); // { value: undefined, done: true }

該方法于keys()方法對應，也是返回一個可迭代對象，其中包含數組中每一項的值

    var a = ["w", "y", "k", "o", "p"];
    var iterator = a.values();

    console.log(iterator.next().value); // w
    console.log(iterator.next().value); // y
    console.log(iterator.next().value); // k
    console.log(iterator.next().value); // o
    console.log(iterator.next().value); // p

該方法用于查找數組中是否包含等于指定值的項。接收兩個參數:

param1,指定被查找是否存在于數組中的值，必須。

param2,指定查找開始的索引值,默認為0，非必需。當傳入負值時，將加上數組的長度值。

[1, 2, 3].includes(4);     // false
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true