摘要：方法將所有在過濾函數中返回的數組元素放進一個新數組中并返回。方法從左到右為每個數組元素執行一次回調函數，并把上次回調函數的返回值放在一個暫存器中傳給下次回調函數，并返回最后一次回調函數的返回值。

var array = new Array();

var array = new Array(10);

var array = new Array("red","blue","green");

var array = [];

var array = [1,2,3,4,5,6];

確定某個對象是否是數組：

value instanceof Array

Array.isArray(value)

toString 方法返回一個字符串，該字符串由數組中的每個元素的 toString() 返回值經調用 join() 方法連接（由逗號隔開）組成

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

toLocaleString() 返回一個字符串表示數組中的元素。數組中的元素將使用各自的 toLocaleString 方法轉成字符串，這些字符串將使用一個特定語言環境的字符串（例如一個逗號 ","）隔開。

valueOf() 方法仍然會返回該數組 (如果放在console.log()中輸出，會自動調用toString方法)

pop():刪除數組的最后一個元素，并返回該元素

push(): 在數組的末尾增加一個或多個元素，并返回新數組的長度

var numbers = [1, 2, 3];
numbers.push(4);
numbers.push(5,6,7);

shift():刪除數組的第一個元素，并返回該元素

push()

unshift():在數組的開頭增加一個或多個元素，并返回新數組的長度

reverse(): 顛倒數組中元素的排列順序

sort(): 對數組元素進行排序，并返回當前數組，默認排序順序是根據字符串的Unicode碼點

var scores = [1, 10, 21, 2]; 
scores.sort();  // [1, 10, 2, 21]  

sort(compareFunction): 對數組元素按照指定的比較方法進行排序，并返回當前數組

如果指明了 compareFunction ，那么數組會按照調用該函數的返回值排序。即 a 和 b 是兩個將要被比較的元素：

如果 compareFunction(a, b) 小于 0 ，那么 a 會被排列到 b 之前；
如果 compareFunction(a, b) 等于 0 ， a 和 b 的相對位置不變。
如果 compareFunction(a, b) 大于 0 ， b 會被排列到 a 之前。
compareFunction(a, b) 必須總是對相同的輸入返回相同的比較結果，否則排序的結果將是不確定的。

var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
  return a - b;
});
console.log(numbers);

// [1, 2, 3, 4, 5]

fill() 方法將一個數組的所有元素從開始索引填充到具有靜態值的結束索引

arr.fill(value, start, end)
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]
[1, 2, 3].fill(4, 1, 1)      // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2)    // [4, 2, 3]

splice()方法:在任意的位置給數組添加或者刪除任意個元素

array.splice(start[, deleteCount][,item1,item2, ...] )

var myFish = ["angel", "clown", "mandarin", "surgeon"];

//從第 2 位開始刪除 0 個元素，插入 "drum"
var removed = myFish.splice(2, 0, "drum");
//運算后的 myFish:["angel", "clown", "drum", "mandarin", "surgeon"]
//被刪除元素數組：[]，沒有元素被刪除

//從第 3 位開始刪除 1 個元素
removed = myFish.splice(3, 1);
//運算后的myFish：["angel", "clown", "drum", "surgeon"]
//被刪除元素數組：["mandarin"]

//從第 2 位開始刪除 1 個元素，然后插入 "trumpet"
removed = myFish.splice(2, 1, "trumpet");
//運算后的myFish: ["angel", "clown", "trumpet", "surgeon"]
//被刪除元素數組：["drum"]

//從第 0 位開始刪除 2 個元素，然后插入 "parrot", "anemone" 和 "blue"
removed = myFish.splice(0, 2, "parrot", "anemone", "blue");
//運算后的myFish：["parrot", "anemone", "blue", "trumpet", "surgeon"]
//被刪除元素的數組：["angel", "clown"]

//從第 3 位開始刪除 2 個元素
removed = myFish.splice(3, Number.MAX_VALUE);
//運算后的myFish: ["parrot", "anemone", "blue"]
//被刪除元素的數組：["trumpet", "surgeon"]

concat(): 返回一個由當前數組和其他若干個數組或者若干個非數組值組合成的新數組

includes():判斷當前數組是否包含指定的值,如果是返回true,否則返回false

join():連接所有數組元素組合成一個字符串,可以想join()傳入連接符號作為參數

slice():抽取當前數組中的一段元素組合成一個新數組

arr.slice();
arr.slice(begin);
arr.alice(begin, end)

var a = ["zero", "one", "two", "three"];
var slice = a.slice(1,3);
console.log(slice); // ["one", "two"]

indexOf():返回數組中第一個與指定值相等的元素的索引,如果找不到,則返回-1

lastIndexOf():返回數組中最后一個與指定值相等的元素的索引,如果找不到,則返回-1

forEach():為數組中的每個元素執行一次回調函數

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

a.forEach(function(element) {
    console.log(element);
});

// a
// b
// c

entries()方法:返回一個新的Array Iterator 對象,該對象包含數組中每個索引的鍵值對

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

every()方法:如果數組中的每個元素都滿足測試函數,則返回true,否則返回false

function isBigEnough(element, index, array) {
  return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
// passed 的值為 false

some()方法: 如果數組中至少有一個元素滿足測試函數，則返回 true，否則返回 false。

filter()方法: 將所有在過濾函數中返回 true 的數組元素放進一個新數組中并返回。

function isBigEnough(value) {
  return value >= 10;
}

var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]

find()方法: 找到第一個滿足測試函數的元素并返回那個元素的值，如果找不到，則返回 undefined。

findIndex()方法: 找到第一個滿足測試函數的元素并返回那個元素的索引，如果找不到，則返回 -1。

map()方法:返回一個由回調函數的返回值組成的新數組。

reduce()方法: 從左到右為每個數組元素執行一次回調函數，并把上次回調函數的返回值放在一個暫存器中傳給下次回調函數，并返回最后一次回調函數的返回值。

var sum = [0, 1, 2, 3].reduce(function(acc, val) {
  return acc + val;
}, 0);

console.log(sum);
// 6