前言

下方的代碼都通過ES6語法，所以您需要先熟悉它。下面我們直奔主題。

示例

Array.from()

Array.from() 方法從一個類似數組或可迭代對象中創建一個新的數組實例。

console.log(Array.from('Javan'));
// output: Array ["J", "a", "v", "a", "n"]
console.log(Array.from([1, 2, 3], x => x + x));
// output: Array [2, 4, 6]

Array.isArray()

Array.every() 測試數組的所有元素是否都通過了指定函數的測試。

let array1 = [2, 30, 39, 29, 10, 13];
console.log(array1.every(currentValue=>currentValue>1));
// output: true

判斷array1裡面的每一個元素是否都大於1， 是返回true，否返回false

Array.fill()

arr.fill(value[, start[, end]]) 用一個固定值填充一個數組中從起始索引到終止索引內的全部元素。

1. 用來填充數組元素的值。
2. 起始索引，默認值為0(可選)。
3. 終止索引，默認值為 this.length。

填充的元素區間是 [start, end) , 一個半開半閉區間

let array1 = [1, 2, 3, 4];
// 用0替換array1從下標2到4的元素，不等於4
console.log(array1.fill(0, 2, 4));
// output: [1, 2, 0, 0]
// 用5替換array1從下標1後面的所有元素
console.log(array1.fill(5, 1));
// output: [1, 5, 5, 5]
// 6替換array1所有元素
console.log(array1.fill(6));
// output: [6, 6, 6, 6]

Array.filter()

let new_array = arr.filter(callback(element[, index[, array]])[, thisArg]) 方法創建一個新數組, 通過callback函數過濾所有元素。

let names = ['Javan', 'Owen', 'Jim', 'Nova'];
let result = names.filter(name => name.length > 4);
console.log(result);
// output: Array ["Javan"]

只取數組names裡面元素長度大於4的，所以得到只有Javan

Array.find()

arr.find(callback[, thisArg]) 返回數組中滿足callback函數的第一個元素的值，否則返回 undefined。

let array1 = [5, 12, 8, 110, 88];
let found = array1.find(element => {
 return element > 10;
});
console.log(found);
// output: 12

Array.findIndex()

arr.findIndex(callback[, thisArg]) 看方法名字就知道和上面的find()對應，上面直接輸出元素，findIndex()肯定是輸出滿足條件元素的下標。

let array1 = [5, 12, 8, 110, 88];
let index = array1.findIndex(element => {
 return element > 10;
});
console.log(index);
// output: 1

Array.forEach()

Array.forEach() 遍歷數組

let array1 = ['j', 'a', 'v', 'a', 'n'];
array1.forEach(element=> {
 console.log(element); 

});
// output: "j"
// output: "a"
// output: "v"
// output: "a"
// output: "n"

Array.includes()

Array.includes() 用來判斷一個數組是否包含一個指定的值，根據情況，如果包含則返回 true，否則返回false。

let array1 = [1, 2, 3];
console.log(array1.includes(2));
// output: true
let names = ['Javan', 'Owen', 'Jim'];
console.log(names.includes('Javan'));
// output: true
console.log(names.includes('Nova'));
// output: false

Array.keys()

Array.keys() 方法返回一個新的Array迭代器，它包含數組中每個索引的鍵。

let array1 = ['j', 'a', 'v', 'a', 'n'];
let iterator = array1.keys(); 
 
for (let key of iterator) {
 console.log(key); 
}
// output: 0
// output: 1
// output: 2
// output: 3 

// output: 4

Array.map()

Array.map() 創建一個新數組，其結果是該數組中的每個元素都調用一個提供的函數後返回的結果。

let array1 = [2, 4, 6, 8];
let map1 = array1.map(item => item * 2);
console.log(map1);
// output: Array [4, 8, 12, 16]

Array.reduce()

arr.reduce(callback[, initialValue]) 數組中的每個元素（從左到右）應用一個函數，將其減少為單個值。

1. accumulator 累加器累加回調的返回值; 它是上一次調用回調時返回的累積值，或initialValue（如下所示）。
2. currentValue 數組中正在處理的元素。
3. currentIndex 數組中正在處理的當前元素的索引。 如果提供了initialValue，則索引號為0，否則為索引為1。
4. initialValue 用作第一個調用 callback的第一個參數的值。 如果沒有提供初始值，則將使用數組中的第一個元素。 在沒有初始值的空數組上調用 reduce 將報錯。

let array1 = [1, 2, 3, 4];
let reducer = (accumulator, currentValue) => accumulator + currentValue;
// 1 + 2 + 3 + 4
console.log(array1.reduce(reducer));
// output: 10
// 5 + 1 + 2 + 3 + 4
console.log(array1.reduce(reducer, 5));
// output: 15

Array.reduceRight()

Array.reduceRight() 與 Array.reduce() 對應，不過是從右至左。

let array1 = [[0, 1], [2, 3], [4, 5]].reduceRight(
 (accumulator, currentValue) => accumulator.concat(currentValue)
);
console.log(array1);
// output: Array [4, 5, 2, 3, 0, 1]

Array.some()

Array.some() 測試數組中的某些元素是否通過由提供的函數實現的測試。

let array = [1, 2, 3, 4, 5];
console.log(array.some(item=> item > 4));
// output: true

判斷array是否有元素大於4，有返回true， 無返回false。

Array.sort()

Array.sort() 對數組的元素進行排序，並返回數組。 sort 排序不一定是穩定的。默認排序順序是根據字符串Unicode碼點。

let months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);
// output: Array ["Dec", "Feb", "Jan", "March"]
let nums = [1, 30, 4, 21];
nums.sort();
console.log(nums);
// output: Array [1, 21, 30, 4]
let names = ['Javan', 'Owen', 'Jim'];
names.sort();
console.log(names);
// output: Array ["Javan", "Jim", "Owen"]

Array.splice()

array.splice(start[, deleteCount[, item1[, item2[, ...]]]]) 通過刪除現有元素和/或添加新元素來更改一個數組的內容。

1. start 指定修改的開始位置（從0計數）。如果超出了數組的長度，則從數組末尾開始添加內容；如果是負值，則表示從數組末位開始的第幾位（從-1計數）；如果負數的絕對值大於數組的長度，則表示開始位置為第0位。
2. deleteCount 整數，表示要移除的數組元素的個數。如果 deleteCount 是 0，則不移除元素。這種情況下，至少應添加一個新元素。如果 deleteCount 大於start 之後的元素的總數，則從 start 後面的元素都將被刪除（含第 start 位）。
3. item1, item2, ... 要添加進數組的元素,從start 位置開始。如果不指定，則 splice() 將只刪除數組元素。

// 從第2位開始刪除0個元素，插入“Nova”
let names1 = ['Javan', 'Owen', 'Jim'];
names1.splice(2, 0, "Nova"); 
console.log(names1);
// output: Array ["Javan", "Owen", "Nova", "Jim"]
// 刪除第2個元素
let names2 = ['Javan', 'Owen', 'Jim'];
names2.splice(2, 1); 
console.log(names2);
// output: Array ["Javan", "Owen"]
// 刪除第2個開始刪除1個元素，插入“Nova”
let names3 = ['Javan', 'Owen', 'Jim'];
names3.splice(2, 1, 'Nova'); 
console.log(names3);
// output: Array ["Javan", "Owen", "Nova"]
// 從第1位開始刪除所有元素
let names4 = ['Javan', 'Owen', 'Jim'];
names4.splice(1); 
console.log(names4);
// output: Array ["Javan"]

小程序開發中，splice應用的地方非常多，因為更改數組對象時，不會重新渲染頁面，必須使用splice修改數組，才會重新渲染。切記切記。

拓展

普通數組去重

let arr = [1, 2, 3, 3];
let resultarr = [...new Set(arr)]; 
console.log(resultarr); 
// output Array [1,2,3]

JSON數組去重

let emps = [{
 name: 'Javan',
 age: '28'
},{
 name: 'Owen',
 age: '25'
},{
 name: 'Javan',
 age: '23'
}];
// 根據name去重
let hash = {};
emps = emps.reduce((item, next) => {
 if (hash[next.name] ? '' : hash[next.name] = true) {
 item.push(next);
 }
 return item;
}, []);
console.log(emps);
// output Array [{name: 'Javan',age: '28'},{name: 'Owen',age: '25'}]

更多資源敬請關注！

閱讀更多 web秀 的文章

關鍵字: 技術 迪吉多 JSON