摘要：簡單總結一下的對象屬性數組指定創建一個數組的函數。方法數組返回一個迭代器，它返回數組的鍵值對。方法數組返回滿足回調函數中指定的測試條件的第一個數組元素的索引值。該回調函數的返回值為累積結果，并且此返回值在下一次調用該回調函數時作為參數提供。

指定創建一個數組的函數。該屬性可用于判斷某個對象是否為數組與arr instanceof Array效果一致

// array.constructor
const x = new Array();
if (x.constructor === Array) {
    console.log("Object is an Array")
} else {
    console.log("Object is not an Array")
}
// Object is an Array

獲取或設置數組的長度。此數值比數組中所定義的最高位元素大 1

const arr = [0,1,2,3,4]
console.log(arr.length) // 5

每個對象都有prototype屬性，Array也屬于對象。在數組的prototype原型對象上添加的屬性，所有的數組對象都能繼承并使用。

Array.prototype.test = "test";
const arr = [];
console.log(arr.test) // "test"

從類似數組的對象或可迭代的對象返回一個數組。該方法是es6新增的函數，在以往將類數組轉化成數組則需要編寫這樣的代碼：Array.slice.call(arrayLike);

// 將dom節點整理成數組
const elemArr = Array.from(document.querySelectorAll("*"));

// 將字符串整理成數組
const charArr = Array.from("abc");
console.log(charArr[0]); // "a"

// 將集合整理成數組
const setObj = new Set("a","b","c");
const objArr = Array.from(setObj);
console.log(objArr[0]); // "a"

// 還可以傳入回調函數對即將生成的數組進行操作
const arr = Array.from(["1","2","3"], x => x * 10);
// arr[0] == 10;
// arr[1] == 20;
// arr[2] == 30;

確定對象是否為數組。使用場景與constructor、instance一致。

var ar1 = [];
var result1 = Array.isArray(ar1);
// Output: true

var ar2 = new Array();
var result2 = Array.isArray(ar2);
// Output: true

var ar3 = [1, 2, 3];
var result3 = Array.isArray(ar3);
// Output: true

var result4 = Array.isArray("an array");
// Output: false

從傳入的參數返回一個數組。
此函數類似于調用 new Array(args)，但當傳入一個參數時，Array.of 不包括特殊行為。

const arr1 = Array.of(3);
console.log(arr1); // [3]

const arr2 = new Array(3);
console.log(arr2); // [undefined, undefined, undefined]

組合兩個或兩個以上的數組。
concat 方法返回一個 Array 對象，它包含 array1 和任何其他提供的項的連接。
要添加的項 (item1 itemN) 會按順序（從列表中的第一個項開始）添加到數組。如果某一項為數組，則其內容將添加到 array1 的末尾。如果該項不是數組，則將其作為單個數組元素添加到數組末尾。
源數組元素按以下規則復制到結果數組：
如果從連接到新數組的任何數組中復制某個對象，則該對象引用仍然指向相同的對象。不論新數組和原始數組中哪一個有改變，都將引起對方的改變。
如果將某個數字或字符串值添加到新數組，則只復制其值。更改一個數組中的值不會影響另一個數組中的值。

var a, b, c, d;
a = new Array(1,2,3);
b = "dog";
c = new Array(42, "cat");
d = a.concat(b, c);
console.log(d); // 1, 2, 3, "dog", 42, "cat"

返回一個迭代器，它返回數組的鍵/值對。

const entries = ["a", "b", "c"].entries();
console.log(entries); // Array Iterator{}
// 在迭代器的原型鏈上包含next方法，調用next可以得到一個對象,這個對象包涵value和done屬性，倘若該迭代器調用next方法value仍然有值則done屬性為false，直到迭代完畢后done屬性返回true
console.log(entries.next().value) // [0, "a"]
console.log(entries.next().value) // [1, "b"]
console.log(entries.next().value) // [2, "c"]

確定數組的所有成員是否滿足指定的測試。

const arr = [1,2,3];
console.log(arr.every(item => item < 3)) // false
console.log(arr.every(item => item < 4)) // true

使用指定值填充數組。

// arr.fill(value, start, end)
// 其中arr為填充的數組，value為填充的值，start為填充的起始位置（可選，默認第一位），end為填充的末尾（可選，默認最后一位），左閉右開區間
[0,0,0].fill(7,1);
// [0,7,7]
[0,0,0].fill(7);
// [7,7,7]

返回數組中的滿足回調函數中指定的條件的元素。
filter()接受一系列的值，對每個值執行一個函數或比較，最后返回一個新數組。這些值都通過它的測試。若都不符合，則返回空數組。

const arr = [1,2,3,4]
const newArr = arr.filter(item => item > 2);
console.log(newArr) // [3,4]

返回滿足回調函數中指定的測試條件的第一個數組元素的索引值。
對于數組中的每個元素，findIndex 方法都會調用一次回調函數（采用升序索引順序），直到有元素返回 true。只要有一個元素返回 true，findIndex 立即返回該返回 true 的元素的索引值。如果數組中沒有任何元素返回 true，則 findIndex 返回 -1。
findIndex 不會改變數組對象。

[1,2,3].findIndex(item => item > 1); // 1
[1,2,3].findIndex(item => item === 3); // 2
[1,2,3].findeIndex(item => item === 4); // -1

為數組中的每個元素執行指定操作。不返回任何值

const arr = [1,2,3]
arr.forEach( (item, index) => {
    console.log(item) // 1, 2, 3
    console.log(index) // 0, 1, 2
})

indexOf 方法在數組中搜索指定的值。該方法返回第一個匹配項的索引；如果找不到指定的值，則為 -1。
搜索按升序索引順序進行。判斷規則采用全等判斷。

var ar = ["ab", "cd", "ef", "ab", "cd"];
console.log(ar.indexOf("ab")); // 0
console.log(ar.indexOf("ab", 1)); // 3
console.log(ar.indexOf("ab", -2)); // 3
console.log(ar.indexOf("ab", 4)); // -1

添加由指定分隔符字符串分隔的數組的所有元素。
如果數組的任一元素為 undefined 或 null，則該元素將被視為空字符串。傳入undefined會被當成空字符串處理，傳入null會當成字符串""null"處理

const a = [1,2,3,4];
const b = a.join("-");
console.log(b); // 1-2-3-4
const c = a.join(undefined);
console.log(c); // 1,2,3,4 
const d = a.join(null);
console.log(d); // 1null2null3null4

返回一個迭代器，它能返回數組的索引值。使用方法與entries類似，只是返回的value值不同

const k = ["a,","b","c","d"].keys();
// k.next().value == 0
// k.next().value == 1
// k.next().value == 2 

lastIndexOf 方法在數組中搜索指定的值。該方法返回第一個匹配項的索引；如果找不到指定的值，則為 -1。
搜索按降序索引順序進行。判斷規則采用全等判斷。

var ar = ["ab", "cd", "ef", "ab", "cd"];
console.log(ar.lastIndexOf("ab")); // 3
console.log(ar.lastIndexOf("ab", 1)); // 0
console.log(ar.lastIndexOf("ab", -2)); // 3
console.log(ar.lastIndexOf("ab", 4)); // 3

對數組的每個元素調用定義的回調函數并返回包含結果的數組。
如果你有一個數組，且希望對該數組每一項執行一些操作，最后返回一個新的數組，那么就用map()

const arr = [1,2,3,4]
const newArr = arr.map( (item, index) => {
    // 這里的item代表每個項的值，index代表每個項的索引
    return item * 2
})
console.log(newArr) // [2,4,6,8] 

從數組中移除最后一個元素并返回該元素。
如果該數組為空，則返回 undefined。
使用 push 和 pop 方法可模擬一個使用先進先出 (LIFO) 的原則來存儲數據的堆棧。

var num;
var arr = new Array();
arr.push(1,2,3);
arr.push(4,5,6);
num = arr.pop();
while(num != undefined) {
    console.log(num);
    num = arr.pop();
}
// 6 5 4 3 2 1

將新元素追加到一個數組中，并返回新的數組長度。
可使用 push 和 pop 方法模擬后進先出堆棧。
push 方法按元素出現的順序附加元素。如果某個參數是數組，則以單個元素的形式添加它。使用 concat 方法要合并兩個或多個數組中的元素。

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

對數組中的所有元素調用指定的回調函數。該回調函數的返回值為累積結果，并且此返回值在下一次調用該回調函數時作為參數提供。
最終只返回一個結果！

//下面的示例將數組值連接成字符串，各個值用“::”分隔開。由于未向 reduce 方法提供初始值，第一次調用回調函數時會將“abc”作為 previousValue 參數并將“def”作為 currentValue 參數。
function appendCurrent (previousValue, currentValue) {
    return previousValue + "::" + currentValue;
    }

var elements = ["abc", "def", 123, 456];

var result = elements.reduce(appendCurrent);
console.log(result) // abc::def::123::456

function addRounded (previousValue, currentValue) {
    return previousValue + Math.round(currentValue);
    }

var numbers = [10.9, 15.4, 0.5];

var result = numbers.reduce(addRounded, 0);
console.log(result) // 27 -> (0 + 11 + 15 +1)

var result2 = numbers.reduce(addRounded);
console.log(result2) // 26.9 -> (10.9 + 15 + 1)

按降序順序對數組中的所有元素調用指定的回調函數。該回調函數的返回值為累積結果，并且此返回值在下一次調用該回調函數時作為參數提供。
使用方式與reduce一致，只是以降序方式執行。
最終只返回一個結果！

反轉 Array 中的元素。該操作會改變原來的數組！
reverse 方法將一個 Array 對象中的元素按所在位置進行反轉。 在執行過程中，此方法并不創建新 Array 對象。
如果數組是不連續的，則 reverse 方法將在數組中創建元素，這些元素將填充數組中的間隙。 所創建的這些元素的值具有值 undefined。

var arr = [1,2,3];
arr.reverse();
console.log(arr); // [3,2,1]

從數組中移除第一個元素并將返回該元素。
使用方式與pop一致，只是刪除的是第一個，而pop是最后一個。

var arr = [1,2,3];
var a = arr.shift();
console.log(a); // 1
console.log(arr) // [2,3]

返回一個數組中的一部分。該操作不會影響原數組！

slice 方法返回一個 Array 對象，其中包含了 arrayObj 的指定部分。

// arrayObj.slice(start, [end])
// arrayObj為操作的數組,start為指定部分起始位置(可選，默認第一個,支持負數),end為制定部分的末尾(可選，默認最后一個,支持負數形式)

var arr = [1,2,3,4];
var a1 = arr.slice(1,1);
console.log(a1) // []
var a2 = arr.slice();
console.log(a2) // [1,2,3,4]
var a3 = arr.slice(-1);
console.log(a3) // 4
var a4 = arr.slice(-3,-1);
console.log(a4) // [2,3]

確定指定的回調函數是否為數組中的任何元素均返回 true。
使用方式與every一致，區別在于every要求每一項都符合要求，而some只需要其中一項符合要求即可。

var arr = [1,2,3,4];
arr.some(item => item > 4); // false
arr.some(item => item > 3); // true

arrayobj.sort(sortFunction)

sort 方法就地對 Array 對象進行排序；在執行過程中不會創建新 Array 對象。該操作會改變原數組!

如果在 sortFunction 參數中提供一個函數，則該函數必須返回下列值之一：
如果所傳遞的第一個參數小于第二個參數，則返回負值。

如果兩個參數相等，則返回零。
如果第一個參數大于第二個參數，則返回正值。

var a = new Array(4, 11, 2, 10, 3, 1);
var b = a.sort();
console.log(b) // [1, 10, 11, 2, 3, 4]
console.log(b === a) // true
a.sort((a,b) => a - b) // 升序排列
a.sort((a,b) => b - a) // 降序排列

// 自定義排列函數,此處僅僅依照大小來排序,可以自定義規則排序大小
function CompareForSort(first, second)
{
    if (first == second)
        return 0;
    if (first < second)
        return -1;
    else
        return 1; 
}
a.sort(CompareForSort)

從一個數組中移除元素，如有必要，在所移除元素的位置上插入新元素，并返回所移除的元素。
該方法會改變原數組！

arrayObj.splice(start, deleteCount, item1, item2...)
arrayObj: 必需。一個 Array 對象
start: 可選。數組中移除元素操作的起點，從 0 開始。默認為 0
deleteCount: 可選。要移除的元素數。默認為arrayObj.length
item1, item2,. . ., itemN: 可選。插入數組中代替已移除元素的元素。

var arr = new Array("4", "11", "2", "10", "3", "1");
var a = arr.splice(0);
console.log(a) // ["4", "11", "2", "10", "3", "1"]
console.log(arr) // []

var arr = new Array("4", "11", "2", "10", "3", "1");
var b = arr.splice(1, 1, 999);
console.log(b) // 11
console.log(arr) // ["4", 999, "2", "10", "3", "1"]

返回數組的字符串表示形式。
將 Array 的元素轉換為字符串。結果字符串被連接起來，用逗號分隔。

var arr = [1, 2, 3, 4];
var s = arr.toString();
console.log(s) // 1,2,3,4

在數組的開頭插入新元素。
unshift 方法將這些元素插入到一個數組的開頭，以便它們按其在參數表中的次序排列。
使用方式與push一致，區別在于push追加到末尾而unshift從起始位置添加

var ar = new Array();
ar.unshift(10, 11);
ar.unshift(12, 13, 14);
consloe.log(ar) // 12,13,14,10,11

返回指定對象的基元值。

var arr = [1,2,3,4]
var s = arr.valueOf()

console.log(arr === s); // true

返回一個迭代器，它返回數組的值。
與keys、entries是一家人，使用方法都一致，區別就在于value不同

var v = ["a", "b", "c"].values();
// v.next().value == "a"
// v.next().value == "b"
// v.next().value == "c"