摘要：數(shù)組轉(zhuǎn)字符串定義方法用于把數(shù)組中的所有元素通過指定的分隔符進行分隔放入一個字符串，返回生成的字符串。該字符串由數(shù)組中的每個元素的返回值經(jīng)調(diào)用方法連接由逗號隔開組成。

在開發(fā)中，數(shù)組的使用場景非常多，平日中也涉及到很多數(shù)組的api/相關操作，一直也沒有對這塊內(nèi)容進行一塊整理總結(jié)，很多時候就算用過幾次這個api，在開發(fā)中也很容易忘記，還是要谷歌一下。所以就希望對這塊內(nèi)容有一個比較系統(tǒng)性的總結(jié)，在這背景下，就有了本篇文章，如果喜歡的話可以點波贊/關注，支持一下，希望大家看完本文可以有所收獲。

個人博客了解一下：obkoro1.com

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

定義：返回由所有參數(shù)值組成的數(shù)組，如果沒有參數(shù)，就返回一個空數(shù)組。

目的：Array.of() 出現(xiàn)的目的是為了解決上述構(gòu)造器因參數(shù)個數(shù)不同，導致的行為有差異的問題。

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

定義：用于將兩類對象轉(zhuǎn)為真正的數(shù)組（不改變原對象，返回新的數(shù)組）。

參數(shù)：

第一個參數(shù)(必需):要轉(zhuǎn)化為真正數(shù)組的對象。

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

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

    // 1. 對象擁有l(wèi)ength屬性
    let obj = {0: "a", 1: "b", 2:"c", length: 3};
    let arr = Array.from(obj); // ["a","b","c"];
    // 2. 部署了 Iterator接口的數(shù)據(jù)結(jié)構(gòu) 比如:字符串、Set、NodeList對象
    let arr = Array.from("hello"); // ["h","e","l","l","o"]
    let arr = Array.from(new Set(["a","b"])); // ["a","b"]

數(shù)組原型提供了非常多的方法，這里分為三類來講，一類會改變原數(shù)組的值，一類是不會改變原數(shù)組，以及數(shù)組的遍歷方法。

    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

對于這些能夠改變原數(shù)組的方法，要注意避免在循環(huán)遍歷中改變原數(shù)組的選項，比如: 改變數(shù)組的長度，導致遍歷的長度出現(xiàn)問題。

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

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

參數(shù):

index：必需。整數(shù)，規(guī)定添加/刪除項目的位置，使用負數(shù)可從數(shù)組結(jié)尾處規(guī)定位置。

howmany：必需。要刪除的項目數(shù)量。如果設置為 0，則不會刪除項目。

item1, ..., itemX： 可選。向數(shù)組添加的新項目。

返回值: 如果有元素被刪除,返回包含被刪除項目的新數(shù)組。

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]
    // 從數(shù)組下標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]
    // 從數(shù)組下標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"]
    // 從數(shù)組最后第二個元素開始，刪除3個元素，并添加兩個元素"添加1"、"添加2"

eg3: 不刪除只添加:

    let a = [1, 2, 3, 4, 5, 6, 7];
    let item = a.splice(0,0,"添加1","添加2"); // [] 沒有刪除元素，返回空數(shù)組
    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"); // [] 沒有刪除元素，返回空數(shù)組
    console.log(b); // [1,2,3,4,5,6,"添加1","添加2",7] 在最后一個元素的前面添加兩個元素

從上述三個栗子可以得出:

數(shù)組如果元素不夠，會刪除到最后一個元素為止

操作的元素，包括開始的那個元素

可以添加很多個元素

添加是在開始的元素前面添加的

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

參數(shù)可選: 規(guī)定排序順序的比較函數(shù)。

默認情況下sort()方法沒有傳比較函數(shù)的話，默認按字母升序，如果不是元素不是字符串的話，會調(diào)用toString()方法將元素轉(zhuǎn)化為字符串的Unicode(萬國碼)位點，然后再比較字符。

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

比較函數(shù)的兩個參數(shù)：

sort的比較函數(shù)有兩個默認參數(shù)，要在函數(shù)中接收這兩個參數(shù)，這兩個參數(shù)是數(shù)組中兩個要比較的元素，通常我們用 a 和 b 接收兩個將要比較的元素：

若比較函數(shù)返回值<0，那么a將排到b的前面;

若比較函數(shù)返回值=0，那么a 和 b 相對位置不變；

若比較函數(shù)返回值>0，那么b 排在a 將的前面；

對于sort()方法更深層級的內(nèi)部實現(xiàn)以及處理機制可以看一下這篇文章深入了解javascript的sort方法

sort排序常見用法：

數(shù)組元素為數(shù)字的升序、降序:

var array = [10, 1, 3, 4,20,4,25,8];
// 升序 a-b < 0 a將排到b的前面，按照a的大小來排序的
// 比如被減數(shù)a是10，減數(shù)是20 10-20 < 0 被減數(shù)a(10)在減數(shù)b(20)前面
array.sort(function(a,b){
return a-b;
});
console.log(array); // [1,3,4,4,8,10,20,25];
// 降序 被減數(shù)和減數(shù)調(diào)換了 20-10>0 被減數(shù)b(20)在減數(shù)a(10)的前面
array.sort(function(a,b){
return b-a;
});
console.log(array); // [25,20,10,8,4,4,3,1];

數(shù)組多條件排序

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

自定義比較函數(shù)，天空才是你的極限

類似的：運用好返回值，我們可以寫出任意符合自己需求的比較函數(shù)

    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() 方法刪除一個數(shù)組中的最后的一個元素，并且返回這個元素。

參數(shù): 無。

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

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

參數(shù): 無。

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

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

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

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

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

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

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

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

參數(shù): 無

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

定義: 在當前數(shù)組內(nèi)部，將指定位置的成員復制到其他位置,并返回這個數(shù)組。

語法:

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

參數(shù):

三個參數(shù)都是數(shù)值，如果不是，會自動轉(zhuǎn)為數(shù)值.

target（必需）：從該位置開始替換數(shù)據(jù)。如果為負值，表示倒數(shù)。

start（可選）：從該位置開始讀取數(shù)據(jù)，默認為 0。如果為負值，表示倒數(shù)。

end（可選）：到該位置前停止讀取數(shù)據(jù)，默認等于數(shù)組長度。使用負數(shù)可從數(shù)組結(jié)尾處規(guī)定位置。

瀏覽器兼容(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"] 

從上述栗子:

第一個參數(shù)是開始被替換的元素位置

要替換數(shù)據(jù)的位置范圍:從第二個參數(shù)是開始讀取的元素，在第三個參數(shù)前面一個元素停止讀取

數(shù)組的長度不會改變

讀了幾個元素就從開始被替換的地方替換幾個元素

定義: 使用給定值，填充一個數(shù)組。

參數(shù):

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

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

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

MDN瀏覽器兼容

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

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

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

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

語法:

    array.slice(begin, end);

參數(shù):

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

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

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

如上：新數(shù)組是淺拷貝的，元素是簡單數(shù)據(jù)類型，改變之后不會互相干擾。

如果是復雜數(shù)據(jù)類型(對象,數(shù)組)的話，改變其中一個，另外一個也會改變。

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

原因在定義上面說過了的：slice()是淺拷貝，對于復雜的數(shù)據(jù)類型淺拷貝，拷貝的只是指向原數(shù)組的指針，所以無論改變原數(shù)組，還是淺拷貝的數(shù)組，都是改變原數(shù)組的數(shù)據(jù)。

定義: join() 方法用于把數(shù)組中的所有元素通過指定的分隔符進行分隔放入一個字符串，返回生成的字符串。

語法:

    array.join(str)

參數(shù):

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

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

使用join方法或者下文說到的toString方法時，當數(shù)組中的元素也是數(shù)組或者是對象時會出現(xiàn)什么情況？

    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
    // 對象轉(zhuǎn)字符串推薦JSON.stringify(obj);

所以，join()/toString()方法在數(shù)組元素是數(shù)組的時候，會將里面的數(shù)組也調(diào)用join()/toString(),如果是對象的話，對象會被轉(zhuǎn)為[object Object]字符串。

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

語法:

    array.toLocaleString()

參數(shù)：無。

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

如上述栗子：調(diào)用數(shù)組的toLocaleString方法，數(shù)組中的每個元素都會調(diào)用自身的toLocaleString方法，對象調(diào)用對象的toLocaleString,Date調(diào)用Date的toLocaleString。

定義: toString() 方法可把數(shù)組轉(zhuǎn)換為由逗號鏈接起來的字符串。

語法:

    array.toString()

參數(shù): 無。

該方法的效果和join方法一樣，都是用于數(shù)組轉(zhuǎn)字符串的，但是與join方法相比沒有優(yōu)勢，也不能自定義字符串的分隔符，因此不推薦使用。

值得注意的是：當數(shù)組和字符串操作的時候，js 會調(diào)用這個方法將數(shù)組自動轉(zhuǎn)換成字符串

   let b= [ "toString","演示"].toString(); // toString,演示
   let a= ["調(diào)用toString","連接在我后面"]+"啦啦啦"; // 調(diào)用toString,連接在我后面啦啦啦

定義： 方法用于合并兩個或多個數(shù)組，返回一個新數(shù)組。

語法：

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

參數(shù)：

arrayX（必須）：該參數(shù)可以是具體的值，也可以是數(shù)組對象?？梢允侨我舛鄠€。

eg1:

    let a = [1, 2, 3];
    let b = [4, 5, 6];
    //連接兩個數(shù)組
    let newVal=a.concat(b); // [1,2,3,4,5,6]
    // 連接三個數(shù)組
    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,"再加一個"]
   // 合并嵌套數(shù)組  會淺拷貝嵌套數(shù)組
   let d = [1,2 ];
   let f = [3,[4]];
   let newVal4 = d.concat(f); // [1,2,3,[4]]

ES6擴展運算符...合并數(shù)組：

因為ES6的語法更簡潔易懂，所以現(xiàn)在合并數(shù)組我大部分采用...來處理，...運算符可以實現(xiàn)cancat的每個栗子，且更簡潔和具有高度自定義數(shù)組元素位置的效果。

    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]

更多關于擴展符的詳細內(nèi)容移步阮一峰大神的ECMAScript 6 入門

定義: 返回在數(shù)組中可以找到一個給定元素的第一個索引，如果不存在，則返回-1。

語法:

    array.indexOf(searchElement,fromIndex)

參數(shù):

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

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

嚴格相等的搜索:

數(shù)組的indexOf搜索跟字符串的indexOf不一樣,數(shù)組的indexOf使用嚴格相等===搜索元素，即數(shù)組元素要完全匹配才能搜索成功。

注意：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

使用場景：

數(shù)組去重

根據(jù)獲取的數(shù)組下標執(zhí)行操作，改變數(shù)組中的值等。

判斷是否存在，執(zhí)行操作。

定義: 方法返回指定元素,在數(shù)組中的最后一個的索引，如果不存在則返回 -1。（從數(shù)組后面往前查找）

語法:

    arr.lastIndexOf(searchElement,fromIndex)

參數(shù):

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

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

關于fromIndex有三個規(guī)則:

正值。如果該值大于或等于數(shù)組的長度，則整個數(shù)組會被查找。

負值。將其視為從數(shù)組末尾向前的偏移。(比如-2，從數(shù)組最后第二個元素開始往前查找)

負值。其絕對值大于數(shù)組長度，則方法返回 -1，即數(shù)組不會被查找。

let a=["OB",4,"Koro1",1,2,"Koro1",3,4,5,"Koro1"]; // 數(shù)組長度為10
// let b=a.lastIndexOf("Koro1",4); // 從下標4開始往前找 返回下標2
// let b=a.lastIndexOf("Koro1",100); // 大于或數(shù)組的長度 查找整個數(shù)組 返回9
// let b=a.lastIndexOf("Koro1",-11); // -1 數(shù)組不會被查找
let b=a.lastIndexOf("Koro1",-9); // 從第二個元素4往前查找，沒有找到 返回-1

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

語法：

    array.includes(searchElement,fromIndex=0)

參數(shù)：

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

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

includes方法是為了彌補indexOf方法的缺陷而出現(xiàn)的:

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 超過數(shù)組長度 不搜索
    // let b=a.includes("Koro1",-3);  // true 從倒數(shù)第三個元素開始搜索 
    // let b=a.includes("Koro1",-100);  // true 負值絕對值超過數(shù)組長度，搜索整個數(shù)組

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

js中遍歷數(shù)組并不會改變原始數(shù)組的方法總共有12個:

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

關于遍歷的效率，可以看一下這篇詳解JS遍歷

盡量不要在遍歷的時候，修改后面要遍歷的值

盡量不要在遍歷的時候修改數(shù)組的長度（刪除/添加）

定義: 按升序為數(shù)組中含有效值的每一項執(zhí)行一次回調(diào)函數(shù)。

語法：

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

參數(shù):

function(必須): 數(shù)組中每個元素需要調(diào)用的函數(shù)。

    // 回調(diào)函數(shù)的參數(shù)
    1. currentValue(必須),數(shù)組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數(shù)組對象本身

thisValue(可選): 當執(zhí)行回調(diào)函數(shù)時this綁定對象的值，默認值為undefined

關于forEach()你要知道：

無法中途退出循環(huán)，只能用return退出本次回調(diào)，進行下一次回調(diào)。

它總是返回 undefined值,即使你return了一個值。

    1. 對于空數(shù)組是不會執(zhí)行回調(diào)函數(shù)的
    2. 對于已在迭代過程中刪除的元素，或者空元素會跳過回調(diào)函數(shù)
    3. 遍歷次數(shù)再第一次循環(huán)前就會確定，再添加到數(shù)組中的元素不會被遍歷。
    4. 如果已經(jīng)存在的值被改變，則傳遞給 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傳遞的第一個參數(shù)"); // 分別打印 1 ,2 ,改變元素
      console.log(this.name); // OBKoro1 打印三次 this綁定在obj對象上
      // break; // break會報錯
      return value; // return只能結(jié)束本次回調(diào) 會執(zhí)行下次回調(diào)
      console.log("不會執(zhí)行，因為return 會執(zhí)行下一次循環(huán)回調(diào)")
    }, obj);
    console.log(result); // 即使return了一個值,也還是返回undefined
    // 回調(diào)函數(shù)也接受接頭函數(shù)寫法

定義: 方法用于檢測數(shù)組所有元素是否都符合函數(shù)定義的條件

語法：

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

參數(shù):(這幾個方法的參數(shù)，語法都類似)

function(必須): 數(shù)組中每個元素需要調(diào)用的函數(shù)。

    // 回調(diào)函數(shù)的參數(shù)
    1. currentValue(必須),數(shù)組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數(shù)組對象本身

thisValue(可選): 當執(zhí)行回調(diào)函數(shù)時this綁定對象的值，默認值為undefined

方法返回值規(guī)則:

如果數(shù)組中檢測到有一個元素不滿足，則整個表達式返回 false，且剩余的元素不會再進行檢測。

如果所有元素都滿足條件，則返回 true。=

eg:

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

定義：數(shù)組中的是否有滿足判斷條件的元素

語法：

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

參數(shù):(這幾個方法的參數(shù)，語法都類似)

function(必須): 數(shù)組中每個元素需要調(diào)用的函數(shù)。

    // 回調(diào)函數(shù)的參數(shù)
    1. currentValue(必須),數(shù)組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數(shù)組對象本身

thisValue(可選): 當執(zhí)行回調(diào)函數(shù)時this綁定對象的值，默認值為undefined

方法返回值規(guī)則：

如果有一個元素滿足條件，則表達式返回true, 剩余的元素不會再執(zhí)行檢測。

如果沒有滿足條件的元素，則返回false。

function isBigEnough(element, index, array) {
return (element >= 10); //數(shù)組中是否有一個元素大于 10
}
let result = [2, 5, 8, 1, 4].some(isBigEnough); // false
let result = [12, 5, 8, 1, 4].some(isBigEnough); // true

定義: 返回一個新數(shù)組, 其包含通過所提供函數(shù)實現(xiàn)的測試的所有元素。

語法：

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

參數(shù):(這幾個方法的參數(shù)，語法都類似)

function(必須): 數(shù)組中每個元素需要調(diào)用的函數(shù)。

    // 回調(diào)函數(shù)的參數(shù)
    1. currentValue(必須),數(shù)組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數(shù)組對象本身

thisValue(可選): 當執(zhí)行回調(diào)函數(shù)時this綁定對象的值，默認值為undefined

eg:

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

定義：創(chuàng)建一個新數(shù)組，其結(jié)果是該數(shù)組中的每個元素都調(diào)用一個提供的函數(shù)后返回的結(jié)果。

語法：

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

參數(shù):(這幾個方法的參數(shù)，語法都類似)

function(必須): 數(shù)組中每個元素需要調(diào)用的函數(shù)。

    // 回調(diào)函數(shù)的參數(shù)
    1. currentValue(必須),數(shù)組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數(shù)組對象本身

thisValue(可選): 當執(zhí)行回調(diào)函數(shù)時this綁定對象的值，默認值為undefined

eg:

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

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

語法：

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

參數(shù)：

function(必須): 數(shù)組中每個元素需要調(diào)用的函數(shù)。

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

initialValue(可選): 指定第一次回調(diào) 的第一個參數(shù)。

回調(diào)第一次執(zhí)行時:

如果 initialValue 在調(diào)用 reduce 時被提供，那么第一個 total 將等于 initialValue，此時 currentValue 等于數(shù)組中的第一個值；

如果 initialValue 未被提供，那么 total 等于數(shù)組中的第一個值，currentValue 等于數(shù)組中的第二個值。此時如果數(shù)組為空，那么將拋出 TypeError。

如果數(shù)組僅有一個元素，并且沒有提供 initialValue，或提供了 initialValue 但數(shù)組為空，那么回調(diào)不會被執(zhí)行，數(shù)組的唯一值將被返回。

eg:

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

這個方法除了與reduce執(zhí)行方向相反外，其他完全與其一致，請參考上述 reduce 方法介紹。

find()定義：用于找出第一個符合條件的數(shù)組成員，并返回該成員，如果沒有符合條件的成員，則返回undefined。

findIndex()定義：返回第一個符合條件的數(shù)組成員的位置，如果所有成員都不符合條件，則返回-1。

這兩個方法

語法：

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

參數(shù):(這幾個方法的參數(shù)，語法都類似)

function(必須): 數(shù)組中每個元素需要調(diào)用的函數(shù)。

    // 回調(diào)函數(shù)的參數(shù)
    1. currentValue(必須),數(shù)組當前元素的值
    2. index(可選), 當前元素的索引值
    3. arr(可選),數(shù)組對象本身

thisValue(可選): 當執(zhí)行回調(diào)函數(shù)時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,

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

語法：

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

參數(shù)：無。

遍歷栗子(摘自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退出循環(huán)。

如果不使用for...of循環(huán)，可以手動調(diào)用遍歷器對象的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支持,，其他瀏覽器未實現(xiàn)，babel轉(zhuǎn)碼器也還未實現(xiàn)

呼~終于寫好了，斷斷續(xù)續(xù)，上班也偷偷劃水的寫了幾天，雖說很辛苦，但是現(xiàn)在對數(shù)組操作方法，整體清晰了很多，各個API也理解的更好一點了，收獲頗多，文章如有不正確的地方歡迎各位大佬鞭策！希望大家看完可以有所收獲，喜歡的話，趕緊點波訂閱關注/喜歡。

個人blog and 掘金個人主頁，如需轉(zhuǎn)載，請放上原文鏈接并署名。碼字不易，感謝支持！本人寫文章本著交流記錄的心態(tài)，寫的不好之處，不撕逼，但是歡迎指點。

如果喜歡本文的話，歡迎關注我的訂閱號，漫漫技術路，期待未來共同學習成長。

以上2018.5.30

ECMAScript6 入門 數(shù)組的擴展

JavaScript Array數(shù)組相關匯總

深入了解javascript的sort方法

【深度長文】JavaScript數(shù)組所有API全解密

詳解JS遍歷

判斷一個變量是否為數(shù)組

在 JavaScript 中，如何求出兩個數(shù)組的交集和差集？