【乾貨】js 數組詳細操做方法及解析合集

時間 2020-02-12

原文原文鏈接

前言

在開發中，數組的使用場景很是多，平日中也涉及到不少數組的api/相關操做，一直也沒有對這塊內容進行一塊整理總結，不少時候就算用過幾回這個api，在開發中也很容易忘記，仍是要谷歌一下。因此就但願對這塊內容有一個比較系統性的總結，在這背景下，就有了本篇文章，若是喜歡的話能夠點波贊/關注，支持一下，但願你們看完本文能夠有所收穫。javascript

我的博客瞭解一下： obkoro1.com

本文篇幅較長，建議點贊保存再看，也便於往後翻閱。

建立一個數組:

// 字面量方式:
    // 這個方法也是咱們最經常使用的，在初始化數組的時候 至關方便
    var a = [3, 11, 8];  // [3,11,8];
    // 構造器:
    // 實際上 new Array === Array,加不加new 一點影響都沒有。
    var a = Array(); // [] 
    var a = Array(3); // [undefined,undefined,undefined]
    var a = Array(3,11,8); // [ 3,11,8 ]

ES6 Array.of() 返回由全部參數值組成的數組

定義：返回由全部參數值組成的數組，若是沒有參數，就返回一個空數組。html

目的：Array.of() 出現的目的是爲了解決上述構造器因參數個數不一樣，致使的行爲有差別的問題。java

let a = Array.of(3, 11, 8); // [3,11,8]
    let a = Array.of(3); // [3]

ES6 Arrary.from() 將兩類對象轉爲真正的數組

定義：用於將兩類對象轉爲真正的數組（不改變原對象，返回新的數組）。git

參數：es6

第一個參數(必需):要轉化爲真正數組的對象。github

第二個參數(可選): 相似數組的map方法，對每一個元素進行處理，將處理後的值放入返回的數組。chrome

第三個參數(可選): 用來綁定this。api

// 1. 對象擁有length屬性
    let obj = {0: 'a', 1: 'b', 2:'c', length: 3};
    let arr = Array.from(obj); // ['a','b','c'];
    // 2. 部署了 Iterator接口的數據結構 好比:字符串、Set、NodeList對象
    let arr = Array.from('hello'); // ['h','e','l','l','o']
    let arr = Array.from(new Set(['a','b'])); // ['a','b']

方法:

數組原型提供了很是多的方法，這裏分爲三類來說，一類會改變原數組的值，一類是不會改變原數組，以及數組的遍歷方法。數組

改變原數組的方法(9個):

let a = [1,2,3];
    ES5:
     a.splice()/ a.sort() / a.pop()/ a.shift()/  a.push()/ a.unshift()/ a.reverse()
    ES6:
    a.copyWithin() / a.fill

對於這些可以改變原數組的方法，要注意避免在循環遍歷中改變原數組的選項，好比: 改變數組的長度，致使遍歷的長度出現問題。瀏覽器

splice() 添加/刪除數組元素

定義： splice() 方法向/從數組中添加/刪除項目，而後返回被刪除的項目

語法： array.splice(index,howmany,item1,.....,itemX)

參數:

index：必需。整數，規定添加/刪除項目的位置，使用負數可從數組結尾處規定位置。
howmany：必需。要刪除的項目數量。若是設置爲 0，則不會刪除項目。
item1, ..., itemX：可選。向數組添加的新項目。

返回值: 若是有元素被刪除,返回包含被刪除項目的新數組。

eg1:刪除元素

let a = [1, 2, 3, 4, 5, 6, 7];
    let item = a.splice(0, 3); // [1,2,3]
    console.log(a); // [4,5,6,7]
    // 從數組下標0開始，刪除3個元素
    let item = a.splice(-1, 3); // [7]
    // 從最後一個元素開始刪除3個元素，由於最後一個元素，因此只刪除了7

eg2: 刪除並添加

let a = [1, 2, 3, 4, 5, 6, 7];
    let item = a.splice(0,3,'添加'); // [1,2,3]
    console.log(a); // ['添加',4,5,6,7]
    // 從數組下標0開始，刪除3個元素，並添加元素'添加'
     let b = [1, 2, 3, 4, 5, 6, 7];
    let item = b.splice(-2,3,'添加1','添加2'); // [6,7]
    console.log(b); // [1,2,3,4,5,'添加1','添加2']
    // 從數組最後第二個元素開始，刪除3個元素，並添加兩個元素'添加1'、'添加2'

eg3: 不刪除只添加:

let a = [1, 2, 3, 4, 5, 6, 7];
    let item = a.splice(0,0,'添加1','添加2'); // [] 沒有刪除元素，返回空數組
    console.log(a); // ['添加1','添加2',1,2,3,4,5,6,7]
    let b = [1, 2, 3, 4, 5, 6, 7];
    let item = b.splice(-1,0,'添加1','添加2'); // [] 沒有刪除元素，返回空數組
    console.log(b); // [1,2,3,4,5,6,'添加1','添加2',7] 在最後一個元素的前面添加兩個元素

從上述三個栗子能夠得出:

數組若是元素不夠，會刪除到最後一個元素爲止
操做的元素，包括開始的那個元素
能夠添加不少個元素
添加是在開始的元素前面添加的

sort() 數組排序

定義: sort()方法對數組元素進行排序，並返回這個數組。

參數可選: 規定排序順序的比較函數。

默認狀況下sort()方法沒有傳比較函數的話，默認按字母升序，若是不是元素不是字符串的話，會調用toString()方法將元素轉化爲字符串的Unicode(萬國碼)位點，而後再比較字符。

// 字符串排列 看起來很正常
    var a = ["Banana", "Orange", "Apple", "Mango"];
    a.sort(); // ["Apple","Banana","Mango","Orange"]
    // 數字排序的時候 由於轉換成Unicode字符串以後，有些數字會比較大會排在後面 這顯然不是咱們想要的
    var    a = [10, 1, 3, 20,25,8];
    console.log(a.sort()) // [1,10,20,25,3,8];

比較函數的兩個參數：

sort的比較函數有兩個默認參數，要在函數中接收這兩個參數，這兩個參數是數組中兩個要比較的元素，一般咱們用 a 和 b 接收兩個將要比較的元素：

若比較函數返回值<0，那麼a將排到b的前面;
若比較函數返回值=0，那麼a 和 b 相對位置不變；
若比較函數返回值>0，那麼b 排在a 將的前面；

對於sort()方法更深層級的內部實現以及處理機制能夠看一下這篇文章深刻了解javascript的sort方法

sort排序常見用法：

數組元素爲數字的升序、降序:
var array = [10, 1, 3, 4,20,4,25,8];
// 升序 a-b < 0 a將排到b的前面，按照a的大小來排序的
// 好比被減數a是10，減數是20 10-20 < 0 被減數a(10)在減數b(20)前面
array.sort(function(a,b){
return a-b;
});
console.log(array); // [1,3,4,4,8,10,20,25];
// 降序被減數和減數調換了 20-10>0 被減數b(20)在減數a(10)的前面
array.sort(function(a,b){
return b-a;
});
console.log(array); // [25,20,10,8,4,4,3,1];
數組多條件排序

var array = [{id:10,age:2},{id:5,age:4},{id:6,age:10},{id:9,age:6},{id:2,age:8},{id:10,age:9}];
```
array.sort(function(a,b){
    if(a.id === b.id){// 若是id的值相等，按照age的值降序
        return b.age - a.age
    }else{ // 若是id的值不相等，按照id的值升序
        return a.id - b.id
    }
})
```
// [{"id":2,"age":8},{"id":5,"age":4},{"id":6,"age":10},{"id":9,"age":6},{"id":10,"age":9},{"id":10,"age":2}]
自定義比較函數，天空纔是你的極限

相似的：運用好返回值，咱們能夠寫出任意符合本身需求的比較函數

var array = [{name:'Koro1'},{name:'Koro1'},{name:'OB'},{name:'Koro1'},{name:'OB'},{name:'OB'}];
    array.sort(function(a,b){
        if(a.name === 'Koro1'){// 若是name是'Koro1' 返回-1 ，-1<0 a排在b的前面
            return -1
        }else{ // 若是不是的話，a排在b的後面
          return 1
        }
    })
    // [{"name":"Koro1"},{"name":"Koro1"},{"name":"Koro1"},{"name":"OB"},{"name":"OB"},{"name":"OB"}]

pop() 刪除一個數組中的最後的一個元素

定義: pop() 方法刪除一個數組中的最後的一個元素，而且返回這個元素。

參數: 無。

let  a =  [1,2,3];
    let item = a.pop();  // 3
    console.log(a); // [1,2]

shift() 刪除數組的第一個元素

定義: shift()方法刪除數組的第一個元素，並返回這個元素。

參數: 無。

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

push() 向數組的末尾添加元素

定義：push() 方法可向數組的末尾添加一個或多個元素，並返回新的長度。

參數: item1, item2, ..., itemX ,要添加到數組末尾的元素

let  a =  [1,2,3];
    let item = a.push('末尾');  // 4
    console.log(a); // [1,2,3,'末尾']

unshift()

定義：unshift() 方法可向數組的開頭添加一個或更多元素，並返回新的長度。

參數: item1, item2, ..., itemX ,要添加到數組開頭的元素

let  a =  [1,2,3];
    let item = a.unshift('開頭');  // 4
    console.log(a); // ['開頭',1,2,3]

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

定義: reverse() 方法用於顛倒數組中元素的順序。

參數: 無

let  a =  [1,2,3];
    a.reverse();  
    console.log(a); // [3,2,1]

ES6: copyWithin() 指定位置的成員複製到其餘位置

定義: 在當前數組內部，將指定位置的成員複製到其餘位置,並返回這個數組。

語法:

array.copyWithin(target, start = 0, end = this.length)

參數:

三個參數都是數值，若是不是，會自動轉爲數值.

target（必需）：從該位置開始替換數據。若是爲負值，表示倒數。
start（可選）：從該位置開始讀取數據，默認爲 0。若是爲負值，表示倒數。
end（可選）：到該位置前中止讀取數據，默認等於數組長度。使用負數可從數組結尾處規定位置。

瀏覽器兼容(MDN): chrome 45,Edge 12,Firefox32,Opera 32,Safari 9, IE 不支持

eg:

// -2至關於3號位，-1至關於4號位
        [1, 2, 3, 4, 5].copyWithin(0, -2, -1)
        // [4, 2, 3, 4, 5]
        var a=['OB1','Koro1','OB2','Koro2','OB3','Koro3','OB4','Koro4','OB5','Koro5']
        // 2位置開始被替換,3位置開始讀取要替換的 5位置前面中止替換
        a.copyWithin(2,3,5)
        // ["OB1","Koro1","Koro2","OB3","OB3","Koro3","OB4","Koro4","OB5","Koro5"]

從上述栗子:

第一個參數是開始被替換的元素位置
要替換數據的位置範圍:從第二個參數是開始讀取的元素，在第三個參數前面一個元素中止讀取
數組的長度不會改變
讀了幾個元素就從開始被替換的地方替換幾個元素

ES6: fill() 填充數組

定義: 使用給定值，填充一個數組。

參數:

第一個元素(必須): 要填充數組的值

第二個元素(可選): 填充的開始位置,默認值爲0

第三個元素(可選)：填充的結束位置，默認是爲this.length

MDN瀏覽器兼容

['a', 'b', 'c'].fill(7)
    // [7, 7, 7]
    ['a', 'b', 'c'].fill(7, 1, 2)
    // ['a', 7, 'c']

不改變原數組的方法(8個):

ES5：
    slice、join、toLocateString、toStrigin、cancat、indexOf、lastIndexOf、
    ES7：
    includes

slice() 淺拷貝數組的元素

定義：方法返回一個從開始到結束（不包括結束）選擇的數組的一部分淺拷貝到一個新數組對象，且原數組不會被修改。

注意：字符串也有一個slice() 方法是用來提取字符串的，不要弄混了。

語法:

array.slice(begin, end);

參數:

begin(可選): 索引數值,接受負值，從該索引處開始提取原數組中的元素,默認值爲0。

end(可選):索引數值(不包括),接受負值，在該索引處前結束提取原數組元素，默認值爲數組末尾(包括最後一個元素)。

let a= ['hello','world'];
    let b=a.slice(0,1); // ['hello']
    a[0]='改變原數組';
    console.log(a,b); // ['改變原數組','world'] ['hello']
    b[0]='改變拷貝的數組';
     console.log(a,b); // ['改變原數組','world'] ['改變拷貝的數組']

如上：新數組是淺拷貝的，元素是簡單數據類型，改變以後不會互相干擾。

若是是複雜數據類型(對象,數組)的話，改變其中一個，另一個也會改變。

let a= [{name:'OBKoro1'}];
    let b=a.slice();
    console.log(b,a); // [{"name":"OBKoro1"}]  [{"name":"OBKoro1"}]
    // a[0].name='改變原數組';
    // console.log(b,a); // [{"name":"改變原數組"}] [{"name":"改變原數組"}]
    // b[0].name='改變拷貝數組',b[0].koro='改變拷貝數組';
    //  [{"name":"改變拷貝數組","koro":"改變拷貝數組"}] [{"name":"改變拷貝數組","koro":"改變拷貝數組"}]

緣由在定義上面說過了的：slice()是淺拷貝，對於複雜的數據類型淺拷貝，拷貝的只是指向原數組的指針，因此不管改變原數組，仍是淺拷貝的數組，都是改變原數組的數據。

join() 數組轉字符串

定義: join() 方法用於把數組中的全部元素經過指定的分隔符進行分隔放入一個字符串，返回生成的字符串。

語法:

array.join(str)

參數:

str(可選): 指定要使用的分隔符，默認使用逗號做爲分隔符。

let a= ['hello','world'];
    let str=a.join(); // 'hello,world'
    let str2=a.join('+'); // 'hello+world'

使用join方法或者下文說到的toString方法時，當數組中的元素也是數組或者是對象時會出現什麼狀況？

let a= [['OBKoro1','23'],'test'];
    let str1=a.join(); // OBKoro1,23,test
    let b= [{name:'OBKoro1',age:'23'},'test'];
    let str2 = b.join(); // [object Object],test
    // 對象轉字符串推薦JSON.stringify(obj);

因此，join()/toString()方法在數組元素是數組的時候，會將裏面的數組也調用join()/toString(),若是是對象的話，對象會被轉爲[object Object]字符串。

toLocaleString() 數組轉字符串

定義: 返回一個表示數組元素的字符串。該字符串由數組中的每一個元素的 toLocaleString() 返回值經調用 join() 方法鏈接（由逗號隔開）組成。

語法:

array.toLocaleString()

參數：無。

let a=[{name:'OBKoro1'},23,'abcd',new Date()];
    let str=a.toLocaleString(); // [object Object],23,abcd,2018/5/28 下午1:52:20

如上述栗子：調用數組的toLocaleString方法，數組中的每一個元素都會調用自身的toLocaleString方法，對象調用對象的toLocaleString,Date調用Date的toLocaleString。

toString() 數組轉字符串不推薦

定義: toString() 方法可把數組轉換爲由逗號連接起來的字符串。

語法:

array.toString()

參數: 無。

該方法的效果和join方法同樣，都是用於數組轉字符串的，可是與join方法相比沒有優點，也不能自定義字符串的分隔符，所以不推薦使用。

值得注意的是：當數組和字符串操做的時候，js 會調用這個方法將數組自動轉換成字符串

let b= [ 'toString','演示'].toString(); // toString,演示
   let a= ['調用toString','鏈接在我後面']+'啦啦啦'; // 調用toString,鏈接在我後面啦啦啦

cancat

定義：方法用於合併兩個或多個數組，返回一個新數組。

語法：

var newArr =oldArray.concat(arrayX,arrayX,......,arrayX)

參數：

arrayX（必須）：該參數能夠是具體的值，也能夠是數組對象。能夠是任意多個。

eg1:

let a = [1, 2, 3];
    let b = [4, 5, 6];
    //鏈接兩個數組
    let newVal=a.concat(b); // [1,2,3,4,5,6]
    // 鏈接三個數組
    let c = [7, 8, 9]
    let newVal2 = a.concat(b, c); // [1,2,3,4,5,6,7,8,9]
    // 添加元素
    let newVal3 = a.concat('添加元素',b, c,'再加一個'); 
    // [1,2,3,"添加元素",4,5,6,7,8,9,"再加一個"]
   // 合併嵌套數組  會淺拷貝嵌套數組
   let d = [1,2 ];
   let f = [3,[4]];
   let newVal4 = d.concat(f); // [1,2,3,[4]]

ES6擴展運算符...合併數組：

由於ES6的語法更簡潔易懂，因此如今合併數組我大部分採用...來處理，...運算符能夠實現cancat的每一個栗子，且更簡潔和具備高度自定義數組元素位置的效果。

let a = [2, 3, 4, 5]
    let b = [ 4,...a, 4, 4]
    console.log(a,b); //  [2, 3, 4, 5] [4,2,3,4,5,4,4]

更多關於擴展符的詳細內容移步阮一峯大神的ECMAScript 6 入門

indexOf() 查找數組是否存在某個元素，返回下標

定義: 返回在數組中能夠找到一個給定元素的第一個索引，若是不存在，則返回-1。

語法:

array.indexOf(searchElement,fromIndex)

參數:

searchElement(必須):被查找的元素

fromIndex(可選):開始查找的位置(不能大於等於數組的長度，返回-1)，接受負值，默認值爲0。

嚴格相等的搜索:

數組的indexOf搜索跟字符串的indexOf不同,數組的indexOf使用嚴格相等===搜索元素，即數組元素要徹底匹配才能搜索成功。

注意：indexOf()不能識別NaN

eg:

let a=['啦啦',2,4,24,NaN]
    console.log(a.indexOf('啦'));  // -1 
    console.log(a.indexOf('NaN'));  // -1 
    console.log(a.indexOf('啦啦')); // 0

使用場景：

數組去重
根據獲取的數組下標執行操做，改變數組中的值等。
判斷是否存在，執行操做。

lastIndexOf() 查找指定元素在數組中的最後一個位置

定義: 方法返回指定元素,在數組中的最後一個的索引，若是不存在則返回 -1。（從數組後面往前查找）

語法:

arr.lastIndexOf(searchElement,fromIndex)

參數:

searchElement(必須): 被查找的元素

fromIndex(可選): 逆向查找開始位置，默認值數組的長度-1，即查找整個數組。

關於fromIndex有三個規則:

正值。若是該值大於或等於數組的長度，則整個數組會被查找。
負值。將其視爲從數組末尾向前的偏移。(好比-2，從數組最後第二個元素開始往前查找)
負值。其絕對值大於數組長度，則方法返回 -1，即數組不會被查找。
let a=['OB',4,'Koro1',1,2,'Koro1',3,4,5,'Koro1']; // 數組長度爲10
// let b=a.lastIndexOf('Koro1',4); // 從下標4開始往前找返回下標2
// let b=a.lastIndexOf('Koro1',100); // 大於或數組的長度查找整個數組返回9
// let b=a.lastIndexOf('Koro1',-11); // -1 數組不會被查找
let b=a.lastIndexOf('Koro1',-9); // 從第二個元素4往前查找，沒有找到返回-1

ES7 includes() 查找數組是否包含某個元素返回布爾

定義：返回一個布爾值，表示某個數組是否包含給定的值

語法：

array.includes(searchElement,fromIndex=0)

參數：

searchElement(必須):被查找的元素

fromIndex(可選):默認值爲0，參數表示搜索的起始位置，接受負值。正值超過數組長度，數組不會被搜索，返回false。負值絕對值超過長數組度，重置從0開始搜索。

includes方法是爲了彌補indexOf方法的缺陷而出現的:

indexOf方法不能識別NaN
indexOf方法檢查是否包含某個值不夠語義化，須要判斷是否不等於-1，表達不夠直觀

eg:

let a=['OB','Koro1',1,NaN];
    // let b=a.includes(NaN); // true 識別NaN
    // let b=a.includes('Koro1',100); // false 超過數組長度 不搜索
    // let b=a.includes('Koro1',-3);  // true 從倒數第三個元素開始搜索 
    // let b=a.includes('Koro1',-100);  // true 負值絕對值超過數組長度，搜索整個數組

兼容性(MDN): chrome47, Firefox 43,Edge 14,Opera 34, Safari 9,IE 未實現。

遍歷方法(12個):

js中遍歷數組並不會改變原始數組的方法總共有12個:

ES5：
    forEach、every 、some、 filter、map、reduce、reduceRight、
    ES6：
    find、findIndex、keys、values、entries

關於遍歷：

關於遍歷的效率，能夠看一下這篇詳解JS遍歷
儘可能不要在遍歷的時候，修改後面要遍歷的值
儘可能不要在遍歷的時候修改數組的長度（刪除/添加）

forEach

定義: 按升序爲數組中含有效值的每一項執行一次回調函數。

語法：

array.forEach(function(currentValue, index, arr), thisValue)

參數:

function(必須): 數組中每一個元素須要調用的函數。

// 回調函數的參數
    1. currentValue(必須),數組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數組對象自己

thisValue(可選): 當執行回調函數時this綁定對象的值，默認值爲undefined

關於forEach()你要知道：

沒法中途退出循環，只能用return退出本次回調，進行下一次回調。
它老是返回 undefined值,即便你return了一個值。

下面相似語法一樣適用這些規則

1. 對於空數組是不會執行回調函數的
    2. 對於已在迭代過程當中刪除的元素，或者空元素會跳過回調函數
    3. 遍歷次數再第一次循環前就會肯定，再添加到數組中的元素不會被遍歷。
    4. 若是已經存在的值被改變，則傳遞給 callback 的值是遍歷到他們那一刻的值。

eg:

let a = [1, 2, ,3]; // 最後第二個元素是空的，不會遍歷(undefined、null會遍歷)
    let obj = { name: 'OBKoro1' };
    let result = a.forEach(function (value, index, array) { 
      a[3] = '改變元素';
      a.push('添加到尾端，不會被遍歷')
      console.log(value, 'forEach傳遞的第一個參數'); // 分別打印 1 ,2 ,改變元素
      console.log(this.name); // OBKoro1 打印三次 this綁定在obj對象上
      // break; // break會報錯
      return value; // return只能結束本次回調 會執行下次回調
      console.log('不會執行，由於return 會執行下一次循環回調')
    }, obj);
    console.log(result); // 即便return了一個值,也仍是返回undefined
    // 回調函數也接受接頭函數寫法

every 檢測數組全部元素是否都符合判斷條件

定義: 方法用於檢測數組全部元素是否都符合函數定義的條件

語法：

array.every(function(currentValue, index, arr), thisValue)

參數:(這幾個方法的參數，語法都相似)

function(必須): 數組中每一個元素須要調用的函數。

// 回調函數的參數
    1. currentValue(必須),數組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數組對象自己

thisValue(可選): 當執行回調函數時this綁定對象的值，默認值爲undefined

方法返回值規則:

若是數組中檢測到有一個元素不知足，則整個表達式返回 false，且剩餘的元素不會再進行檢測。
若是全部元素都知足條件，則返回 true。=

eg:

function isBigEnough(element, index, array) { 
      return element >= 10; // 判斷數組中的全部元素是否都大於10
    }
    let result = [12, 5, 8, 130, 44].every(isBigEnough);   // false
    let result = [12, 54, 18, 130, 44].every(isBigEnough); // true
    // 接受箭頭函數寫法 
    [12, 5, 8, 130, 44].every(x => x >= 10); // false
    [12, 54, 18, 130, 44].every(x => x >= 10); // true

some 數組中的是否有知足判斷條件的元素

定義：數組中的是否有知足判斷條件的元素

語法：

array.some(function(currentValue, index, arr), thisValue)

參數:(這幾個方法的參數，語法都相似)

function(必須): 數組中每一個元素須要調用的函數。

// 回調函數的參數
    1. currentValue(必須),數組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數組對象自己

thisValue(可選): 當執行回調函數時this綁定對象的值，默認值爲undefined

方法返回值規則：

若是有一個元素知足條件，則表達式返回true, 剩餘的元素不會再執行檢測。
若是沒有知足條件的元素，則返回false。
function isBigEnough(element, index, array) {
return (element >= 10); //數組中是否有一個元素大於 10
}
let result = [2, 5, 8, 1, 4].some(isBigEnough); // false
let result = [12, 5, 8, 1, 4].some(isBigEnough); // true

filter 過濾原始數組，返回新數組

定義: 返回一個新數組, 其包含經過所提供函數實現的測試的全部元素。

語法：

let new_array = arr.filter(function(currentValue, index, arr), thisArg)

參數:(這幾個方法的參數，語法都相似)

function(必須): 數組中每一個元素須要調用的函數。

// 回調函數的參數
    1. currentValue(必須),數組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數組對象自己

thisValue(可選): 當執行回調函數時this綁定對象的值，默認值爲undefined

eg:

let a = [32, 33, 16, 40];
    let result = a.filter(function (value, index, array) {
      return value >= 18; // 返回a數組中全部大於18的元素
    });
    console.log(result,a);// [32,33,40] [32,33,16,40]

map 對數組中的每一個元素進行處理，返回新的數組

定義：建立一個新數組，其結果是該數組中的每一個元素都調用一個提供的函數後返回的結果。

語法：

let new_array = arr.map(function(currentValue, index, arr), thisArg)

參數:(這幾個方法的參數，語法都相似)

function(必須): 數組中每一個元素須要調用的函數。

// 回調函數的參數
    1. currentValue(必須),數組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數組對象自己

thisValue(可選): 當執行回調函數時this綁定對象的值，默認值爲undefined

eg:

let a = ['1','2','3','4'];
let result = a.map(function (value, index, array) {
  return value + '新數組的新元素'
});
console.log(result, a); 
// ["1新數組的新元素","2新數組的新元素","3新數組的新元素","4新數組的新元素"] ["1","2","3","4"]

reduce 爲數組提供累加器，合併爲一個值

定義：reduce() 方法對累加器和數組中的每一個元素（從左到右）應用一個函數，最終合併爲一個值。

語法：

array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

參數：

function(必須): 數組中每一個元素須要調用的函數。

// 回調函數的參數
    1. total(必須)，初始值, 或者上一次調用回調返回的值
    2. currentValue(必須),數組當前元素的值
    3. index(可選), 當前元素的索引值
    4. arr(可選),數組對象自己

initialValue(可選): 指定第一次回調的第一個參數。

回調第一次執行時:

若是 initialValue 在調用 reduce 時被提供，那麼第一個 total 將等於 initialValue，此時 currentValue 等於數組中的第一個值；
若是 initialValue 未被提供，那麼 total 等於數組中的第一個值，currentValue 等於數組中的第二個值。此時若是數組爲空，那麼將拋出 TypeError。
若是數組僅有一個元素，而且沒有提供 initialValue，或提供了 initialValue 但數組爲空，那麼回調不會被執行，數組的惟一值將被返回。

eg:

// 數組求和 
    let sum = [0, 1, 2, 3].reduce(function (a, b) {
      return a + b;
    }, 0);
    // 6
    // 將二維數組轉化爲一維 將數組元素展開
    let flattened = [[0, 1], [2, 3], [4, 5]].reduce(
      (a, b) => a.concat(b),
      []
    );
     // [0, 1, 2, 3, 4, 5]

reduceRight 從右至左累加

這個方法除了與reduce執行方向相反外，其餘徹底與其一致，請參考上述 reduce 方法介紹。

ES6：find()& findIndex() 根據條件找到數組成員

find()定義：用於找出第一個符合條件的數組成員，並返回該成員，若是沒有符合條件的成員，則返回undefined。

findIndex()定義：返回第一個符合條件的數組成員的位置，若是全部成員都不符合條件，則返回-1。

這兩個方法

語法：

let new_array = arr.find(function(currentValue, index, arr), thisArg)
     let new_array = arr.findIndex(function(currentValue, index, arr), thisArg)

參數:(這幾個方法的參數，語法都相似)

function(必須): 數組中每一個元素須要調用的函數。

// 回調函數的參數
    1. currentValue(必須),數組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數組對象自己

thisValue(可選): 當執行回調函數時this綁定對象的值，默認值爲undefined

這兩個方法均可以識別NaN,彌補了indexOf的不足.

eg:

// find
        let a = [1, 4, -5, 10].find((n) => n < 0); // 返回元素-5
        let b = [1, 4, -5, 10,NaN].find((n) => Object.is(NaN, n));  // 返回元素NaN
        // findIndex
        let a = [1, 4, -5, 10].findIndex((n) => n < 0); // 返回索引2
        let b = [1, 4, -5, 10,NaN].findIndex((n) => Object.is(NaN, n));  // 返回索引4

瀏覽器兼容(MDN):Chrome 45,Firefox 25,Opera 32, Safari 8, Edge yes,

ES6 keys()&values()&entries() 遍歷鍵名、遍歷鍵值、遍歷鍵名+鍵值

定義：三個方法都返回一個新的 Array Iterator 對象，對象根據方法不一樣包含不一樣的值。

語法：

array.keys()
    array.values()
    array.entries()

參數：無。

遍歷栗子(摘自ECMAScript 6 入門)：

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"

在for..of中若是遍歷中途要退出，可使用break退出循環。

若是不使用for...of循環，能夠手動調用遍歷器對象的next方法，進行遍歷:

let letter = ['a', 'b', 'c'];
    let entries = letter.entries();
    console.log(entries.next().value); // [0, 'a']
    console.log(entries.next().value); // [1, 'b']
    console.log(entries.next().value); // [2, 'c']

entries()瀏覽器兼容性(MDN):Chrome 38, Firefox 28,Opera 25,Safari 7.1

keys()瀏覽器兼容性(MDN):Chrome 38, Firefox 28,Opera 25,Safari 8,

注意:目前只有Safari 9支持,，其餘瀏覽器未實現，babel轉碼器也還未實現