摘要：用于找出第一個(gè)滿足提供的回調(diào)函數(shù)的數(shù)組成員。由被刪除的數(shù)組元素組成的一個(gè)數(shù)組。返回一個(gè)字符串，表示指定的數(shù)組及其元素

Array.from() ：從一個(gè)類似數(shù)組或者可迭代對象中創(chuàng)建一個(gè)新的數(shù)組實(shí)例。
用一種更通俗易懂的方式來說，就是Array.from方法用于將兩類對象轉(zhuǎn)為真正數(shù)組：類數(shù)組對象（array-like object）和可遍歷（iterable）的對象。
實(shí)際應(yīng)用中，常見的類數(shù)組對象是 DOM 操作返回的 NodeList 集合，以及函數(shù)內(nèi)部的arguments對象。Array.from都可以將它們轉(zhuǎn)為真正的數(shù)組。
語法：Array.from(arrayLike[, mapFn[, thisArg]])
參數(shù)：
arrayLike 想要轉(zhuǎn)換成數(shù)組的偽數(shù)組對象或可迭代對象。
mapFn (可選參數(shù)) 如果指定了該參數(shù)，新數(shù)組中的每個(gè)元素會(huì)執(zhí)行該回調(diào)函數(shù)。
thisArg (可選參數(shù)) 可選參數(shù)，執(zhí)行回調(diào)函數(shù) mapFn 時(shí) this 對象。
返回值： 一個(gè)新的數(shù)組實(shí)例

// arguments對象
function foo() {
  var args = Array.from(arguments);
  // ...
}
Array.from("hello")
// ["h", "e", "l", "l", "o"]

// Using an arrow function as the map function to
// manipulate the elements
Array.from([1, 2, 3], x => x + x);      
// [2, 4, 6]

Array.isArray() 用于確定傳遞的值是否是一個(gè) Array
語法：Array.isArray(obj)
參數(shù)：obj 需要檢測的值;
返回值：如果對象是 Array，則為true; 否則為false

Array.isArray([1, 2, 3]);  
// true
Array.isArray({foo: 123}); 
// false
Array.isArray("foobar");   
// false
Array.isArray(undefined);  
// false

Array.of方法用于將一組值，轉(zhuǎn)換為數(shù)組
語法：Array.of(element0[, element1[, ...[, elementN]]])
參數(shù)：
elementN
任意個(gè)參數(shù)，將按順序成為返回?cái)?shù)組中的元素。
返回值：新的 Array 實(shí)例。
Array.of 和構(gòu)造函數(shù)Array的區(qū)別

Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1

Array() // []
Array(3) // [, , ,]
Array(3, 11, 8) // [3, 11, 8]

Array方法沒有參數(shù)、一個(gè)參數(shù)、三個(gè)參數(shù)時(shí)，返回結(jié)果都不一樣。只有當(dāng)參數(shù)個(gè)數(shù)不少于 2 個(gè)時(shí)，Array()才會(huì)返回由參數(shù)組成的新數(shù)組。參數(shù)個(gè)數(shù)只有一個(gè)時(shí)，實(shí)際上是指定數(shù)組的長度。
Array.of基本上可以用來替代Array()或new Array()，并且不存在由于參數(shù)不同而導(dǎo)致的重載。它的行為非常統(tǒng)一。

Array.prototype.forEach：對數(shù)組的每個(gè)元素執(zhí)行一次提供的函數(shù)
語法：

array.forEach(callback(currentValue, index, array){
    //do something
}, this)

參數(shù):
callback: 為數(shù)組中每個(gè)元素執(zhí)行的函數(shù)，該函數(shù)接收下面3個(gè)參數(shù)；
currentValue: 當(dāng)前數(shù)組元素；
index（可選）: 當(dāng)前數(shù)組索引；
array（可選）: 被遍歷的數(shù)組本身；
this（可選）: 當(dāng)執(zhí)行callback回調(diào)函數(shù)時(shí)用作this的值（參考對象）
返回值：undefined
示例：

// 打印每個(gè)數(shù)組元素
function logArrayElements(element, index, array) {
  console.log("a[" + index + "] = " + element);
}

Array.prototype.map(): 創(chuàng)建一個(gè)新數(shù)組，其結(jié)果是該數(shù)組中的每個(gè)元素都調(diào)用一個(gè)提供的函數(shù)后返回的結(jié)果
語法：

var new_array = arr.map(function callback(currentValue[, index[, array]]) {
 // Return element for new_array }[, 
thisArg])

參數(shù)：
callback:生成新數(shù)組元素的函數(shù)，有下面3個(gè)參數(shù)：
currentValue: 當(dāng)前數(shù)組元素；
index（可選）: 當(dāng)前數(shù)組索引；
array（可選）: 被遍歷的數(shù)組本身；
thisArg（可選）: 當(dāng)執(zhí)行callback回調(diào)函數(shù)時(shí)用作this的值（參考對象）
返回值：一個(gè)新數(shù)組，每個(gè)元素都是回調(diào)函數(shù)的結(jié)果。
示例：

// 求數(shù)組中每個(gè)元素的平方根
let arr = [1, 4, 9];
let new_arr = arr.map(currentValue => {
  return Math.sqrt(currentValue)
})
console.log(new_arr)

Array.prototype.reduce()：reduce方法把一個(gè)函數(shù)作用在數(shù)組的所有元素。這個(gè)函數(shù)必須接收至少兩個(gè)參數(shù)，reduce()把函數(shù)的返回結(jié)果繼續(xù)和數(shù)組的下一個(gè)元素做累積計(jì)算
語法：

arr.reduce(function callback(accumulator, currentValue[, currentIndex, array]) {
  // coding...
}[, initialValue)

參數(shù)：
callback: 執(zhí)行數(shù)組中每個(gè)值的函數(shù)，包含四個(gè)參數(shù)：
accumulator: 函數(shù)回調(diào)的返回值；它是上一次調(diào)用回調(diào)時(shí)返回的累積值，或initialValue（見于下方）。
currentValue: 數(shù)組正在處理的元素。
currentIndex: 數(shù)組中正在處理的當(dāng)前元素的索引。如果提供了initialValue，則索引號(hào)未0，否則索引為1。
array: 調(diào)用reduce()的數(shù)組。
initialValue: 作為第一次調(diào)用 callback函數(shù)時(shí)的第一個(gè)參數(shù)的值。 如果沒有提供初始值，則將使用數(shù)組中的第一個(gè)元素。 在沒有初始值的空數(shù)組上調(diào)用 reduce 將報(bào)錯(cuò)。
返回值：函數(shù)累計(jì)處理的結(jié)果。
示例：

// 求數(shù)組中每個(gè)元素的和
var arr = [1, 2, 3, 4];
var sum = arr.reduce(function (x, y) {
  return x + y;
}
// 10

Array.prototype.reduceRight():reduceRight方法把一個(gè)函數(shù)作用在數(shù)組的所有元素。這個(gè)函數(shù)必須接收至少兩個(gè)參數(shù)，reduceRight()把函數(shù)的返回結(jié)果繼續(xù)和數(shù)組的下一個(gè)元素做累積計(jì)算。和reduce不同的是，reduceRight的遍歷順序是從右到左。

Array.prototype.every(): every方法測試數(shù)組的所有元素是否都通過了指定元素的測試。
語法：

arr.erery(callback[, thisArg])

參數(shù)：
callback：用來測試每個(gè)元素的函數(shù)。
thisArg：執(zhí)行callback時(shí)內(nèi)部指定的this值。
示例：

var arr = [1, 2, 3, 4, 11];
var passed = arr.every(function (x) {
  return x < 10;
}
// passed is false

Array.prototype.some():some方法測試數(shù)組的所有元素中是否有通過測試的。
語法：

arr.some(callback[, thisArg])

參數(shù)：
callback：用來測試每個(gè)元素的函數(shù)。
thisArg：執(zhí)行callback時(shí)內(nèi)部指定的this值。
示例：

var arr = [1, 2, 3, 4, 10];
var passed = arr.some(function (x) {
  return x < 10;
}
// passed is true

Array.prototype.filter(): filter()方法創(chuàng)建一個(gè)數(shù)組，其包含通過所提供函數(shù)實(shí)現(xiàn)的測試的所有元素。
語法：

var new_array = arr.filter(callback(element[, index[, array]])[, thisArg])

參數(shù)：
callback
用來測試數(shù)組的每個(gè)元素的函數(shù)。調(diào)用時(shí)使用參數(shù)（element, index, array）。
返回true表示保留該元素（通過測試），false則不保留，它接受三個(gè)參數(shù)：
element 當(dāng)前在數(shù)組中處理的元素
index(可選） 正在處理元素在數(shù)組中的索引
array（可選） 調(diào)用了filter的數(shù)組
thisArg（可選） 執(zhí)行callback時(shí)的用于 this 的值

示例：

var filtered = [12, 5, 8, 130, 44].filter(currentValue => {
  return currentValue > 10;
});
// filtered is [12, 130, 44]

Array.prototype.keys(): 對數(shù)組鍵名（也就是索引值）的遍歷，返回一個(gè)遍歷器對象。
Array.prototype.value(): 對數(shù)組鍵值（也就是數(shù)組元素）的遍歷，返回一個(gè)遍歷器對象。
Array.prototype.entries: 對數(shù)組鍵值對（索引值，對應(yīng)數(shù)組元素）的遍歷，返回一個(gè)遍歷器對象。

直接上示例代碼：

for (let index of ["a", "b"].keys()) {
  console.log(index);
}
// 0
// 1

for (let elem of ["a", "b"].values()) {
  console.log(elem);
}
// "a"
// "b"

for (let [index, elem] of ["a", "b"].entries()) {
  console.log(index, elem);
}
// 0 "a"
// 1 "b"

Array.prototype.find(): 用于找出第一個(gè)滿足提供的回調(diào)函數(shù)的數(shù)組成員。所有數(shù)組成員依次執(zhí)行該回調(diào)函數(shù)，直到找出第一個(gè)返回值為true的成員，然后返回該成員。否則返回undefined。
Array.prototype.findIndex():用于找出第一個(gè)滿足提供的回調(diào)函數(shù)的數(shù)組成員。所有數(shù)組成員依次執(zhí)行該回調(diào)函數(shù)，直到找出第一個(gè)返回值為true的成員，然后返回該成員的位置（也就是索引）。否則返回-1。
語法：

arr.find(callback[, thisArg]);
arr.findIndex(callback[, thisArg]);

參數(shù)：
callback
針對數(shù)組中的每個(gè)元素, 都會(huì)執(zhí)行該回調(diào)函數(shù), 執(zhí)行時(shí)會(huì)自動(dòng)傳入下面三個(gè)參數(shù):
element 當(dāng)前元素。
index 當(dāng)前元素的索引。
array 調(diào)用findIndex的數(shù)組。
thisArg 可選。執(zhí)行callback時(shí)作為this對象的值.

示例：

[1, 5, 10, 15].find(function(value, index, arr) {
  return value % 2 == 0;
}) // 10
[1, 5, 10, 15].find(function(value, index, arr) {
  return value % 2 == 0;
}) // 2

Array.prototype.indexOf：indexOf方法返回在數(shù)組中可以找到一個(gè)給定元素的第一個(gè)索引，如果不存在，則返回-1。
Array.prototype.lastIndexOf：lastIndexOf方法返回在數(shù)組中可以找到一個(gè)給定元素的最后一個(gè)索引（從數(shù)組的后面向前查找），如果不存在，則返回-1。
語法：

arr.indexOf(searchElement[, fromIndex = 0])
arr.lastIndexOf(searchElement[, fromIndex = 0])

參數(shù)：
searchElement 要查找的元素
fromIndex 開始查找的位置（對indexOf而言）或者開始逆向查找的位置（對lastIndexOf而言）
示例：

var indexof = [1, 5, 10, 5].indexOf(5) // 1
var lastindexof = [1, 5, 10, 5].indexOf(5) // 3

Array.prototype.includes(): includes() 方法用來判斷一個(gè)數(shù)組是否包含一個(gè)指定的值，根據(jù)情況，如果包含則返回 true，否則返回false。
語法：

arr.includes(searchElement, fromIndex)

參數(shù)：
searchElement 需要查找的元素值。
fromIndex 可選 從該索引處開始查找 searchElement。如果為負(fù)值，則按升序從 array.length - fromIndex 的索引開始搜索。默認(rèn)為 0。

Array.prototype.pop: 從數(shù)組中刪除最后一個(gè)元素，并返回該元素的值。此方法改變數(shù)組的長度。
Array.prototype.push: 將一個(gè)或多個(gè)元素添加到數(shù)組的末尾，并返回該數(shù)組的新長度。
示例：

// pop
let myFish = ["angel", "clown", "mandarin", "surgeon"];

let popped = myFish.pop();

console.log(myFish); 
// ["angel", "clown", "mandarin"]

console.log(popped); 
// surgeon

// push
var sports = ["soccer", "baseball"];
var total = sports.push("football", "swimming");

console.log(sports); 
// ["soccer", "baseball", "football", "swimming"]

console.log(total);  
// 4

Array.prototype.shift(): 從數(shù)組中刪除第一個(gè)元素，并返回該元素的值。此方法更改數(shù)組的長度。
Array.prototype.unshift(): 將一個(gè)或多個(gè)元素添加到數(shù)組的開頭，并返回該數(shù)組的新長度。
示例：

// shift
let myFish = ["angel", "clown", "mandarin", "surgeon"];

let shift_length = myFish.shift();

console.log(myFish); 
// ["clown", "mandarin", "surgeon"]

console.log(shift_length); 
// angel

// unshift
let sports = ["soccer", "baseball"];
let unshift_length = sports.unshift("football", "swimming");

console.log(sports); 
// ["football", "swimming", "soccer", "baseball"]

Array.prototype.splice: 通過刪除現(xiàn)有元素和/或添加新元素來更改一個(gè)數(shù)組的內(nèi)容
語法：array.splice(start[, deleteCount[, item1[, item2[, ...]]]])

參數(shù)：
start?：指定修改的開始位置（從0開始計(jì)數(shù)）
deleteCount：可選 指定要?jiǎng)h除的數(shù)組元素的個(gè)數(shù)，如果省略該參數(shù)，則從start開始的所有數(shù)組元素都被刪除（包括第start位）
item1, item2, ... : 可選，要添加進(jìn)數(shù)組的元素，如果省略該參數(shù)，則只刪除數(shù)組元素
返回值：
如果沒有刪除元素，則返回空數(shù)組。由被刪除的數(shù)組元素組成的一個(gè)數(shù)組。如果只刪除了一個(gè)元素，則返回只包含一個(gè)元素的數(shù)組。
示例：

var myFish = ["angel", "clown", "drum", "mandarin", "sturgeon"];
var removed = myFish.splice(3, 1, "big", "small");
console.log(myFish);
console.log(removed)
// > Array ["angel", "clown", "drum", "big", "small", "sturgeon"]
// > Array ["mandarin"]

Array.prototype.concat(): 拼接兩個(gè)或者多個(gè)數(shù)組，此方法不會(huì)修改原數(shù)組，而是返回一個(gè)新的數(shù)組。
示例：

var arr1 = [1, 2, 3];
var arr2 = [4, 5, 6];
var new_arr = arr1.concat(arr2);
// new_arr [1, 2, 3, 4, 5, 6]

Array.prototype.slice(): 返回一個(gè)新的數(shù)組對象，這一對象是一個(gè)由 begin和end(不包括end)決定的原數(shù)組的淺拷貝。原始數(shù)組不會(huì)被改變。
語法：arr.slice(begin, end);
參數(shù)：
begin： 可選 從該索引處開始提取原數(shù)組中的元素，如果省略該參數(shù)，則從0開始。
end： 可選 從該索引處結(jié)束提取原數(shù)組中的元素，如果省略該參數(shù)，則會(huì)一直提取到原數(shù)組末尾。
示例：

var arr = [1, 2, 3, 4, 5, 6];
var sub_arr = arr.splice(1, 4);
// sub_arr [2, 3, 4]

Array.prototype.reverse(): 將數(shù)組中元素的位置顛倒，第一個(gè)數(shù)組元素成為最后一個(gè)數(shù)組元素，最后一個(gè)數(shù)組元素成為第一個(gè)。
示例：

var arr = [1, 2, 3, 4, 5, 6];
arr.reverse();
// arr -> [6, 5, 4, 3, 2, 1]

Array.prototype.sort():MDN給出的定義是用原地算法對數(shù)組的元素進(jìn)行排序，并返回?cái)?shù)組。排序不一定是穩(wěn)定的。默認(rèn)排序順序是根據(jù)字符串Unicode碼點(diǎn)。具體是咋排的我也不知道，我的理解就是按照字符串的Unicode碼點(diǎn)進(jìn)行排序的。
語法：arr.sort([compareFunction])
參數(shù)：
compareFunction: 用來指定按某種順序進(jìn)行排列的函數(shù)。如果省略，元素按照轉(zhuǎn)換為的字符串的各個(gè)字符的Unicode位點(diǎn)進(jìn)行排序;如果不省略 compareFunction ，那么數(shù)組會(huì)按照調(diào)用該函數(shù)的返回值排序。即 a 和 b 是兩個(gè)將要被比較的元素：

如果 compareFunction(a, b) 小于 0 ，那么 a 會(huì)被排列到 b 之前；

如果 compareFunction(a, b) 等于 0 ， a 和 b 的相對位置不變。備注： ECMAScript
標(biāo)準(zhǔn)并不保證這一行為，而且也不是所有瀏覽器都會(huì)遵守（例如 Mozilla 在 2003 年之前的版本）；

如果 compareFunction(a, b) 大于 0 ， b 會(huì)被排列到 a 之前。

compareFunction(a, b) 必須總是對相同的輸入返回相同的比較結(jié)果，否則排序的結(jié)果將是不確定的。

示例：

//升序
function sort_increase(a, b) {
 return a - b
}
// 降序
function sort_decrease(a, b) {
 return b - a
}
var arr = [3, 0 ,6 ,2 ,4 ,7]
arr.sort(sort_increase)
console.log(arr)

arr.sort(sort_decrease)
console.log(arr)

// > Array [7, 6, 4, 3, 2, 0]
// > Array [0, 2, 3, 4, 6, 7]

Array.prototype.copyWith():在當(dāng)前數(shù)組內(nèi)部，將指定位置的成員復(fù)制到其他位置（會(huì)覆蓋原有成員），然后返回當(dāng)前數(shù)組。也就是說，這個(gè)方法會(huì)修改原有數(shù)組。
語法：arr.prototype.copyWith(target, start = 0, end = this.length)
參數(shù)：
target（必需）：從該位置開始替換數(shù)據(jù)。如果為負(fù)值，表示倒數(shù)。
start（可選）：從該位置開始讀取數(shù)據(jù)，默認(rèn)為 0。如果為負(fù)值，表示倒數(shù)。
end（可選）：到該位置前停止讀取數(shù)據(jù)，默認(rèn)等于數(shù)組長度。如果為負(fù)值，表示倒數(shù)。
示例：

[1, 2, 3, 4, 5].copyWithin(0, 3)
// [4, 5, 3, 4, 5]

Array.prototype.fill(): 使用給定值，填充一個(gè)數(shù)組。這個(gè)方法會(huì)修改原有數(shù)組。

語法：arr.fill(value[, start[, end]])
參數(shù)：
value 用來填充數(shù)組元素的值。
start 可選 起始索引，默認(rèn)值為0。
end 可選 終止索引(不包括該位置)，默認(rèn)值為 this.length。
示例：

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

Array.protytye.join(): 一個(gè)數(shù)組（或一個(gè)類數(shù)組對象）的所有元素連接成一個(gè)字符串并返回這個(gè)字符串。
語法：arr.join(separator)
參數(shù)：
separator 指定一個(gè)字符串來分隔數(shù)組的每個(gè)元素，如果省略()，數(shù)組元素用逗號(hào)分隔。默認(rèn)為 ","。

Array.prototype.toLocalString(): 返回一個(gè)字符串表示數(shù)組中的元素。數(shù)組中的元素將使用各自的 toLocaleString 方法轉(zhuǎn)成字符串，這些字符串將使用一個(gè)特定語言環(huán)境的字符串（例如一個(gè)逗號(hào) ","）隔開。
Array.prototype.toString(): 返回一個(gè)字符串，表示指定的數(shù)組及其元素.