數(shù)組的方法有數(shù)組原型方法，也有從object對象繼承來的方法，下面就介紹一下數(shù)組常用方法：
join() ------------------------數(shù)組轉(zhuǎn)字符串
split() -----------------------字符串轉(zhuǎn)數(shù)組
push() ----------------------將數(shù)據(jù)添加到數(shù)組尾部
pop() -----------------------數(shù)組末尾移除最后一項
shift() -----------------------刪除原數(shù)組第一項
unshift() --------------------將數(shù)據(jù)添加到數(shù)組頭部
sort() ------------------------按升序排列數(shù)組項
reverse() --------------------反轉(zhuǎn)數(shù)組項的順序
concat() --------------------多個數(shù)組合并，原數(shù)組不變
slice() -----------------------返回開始下標(biāo)到結(jié)束下標(biāo)之間的項組成的新數(shù)組，原數(shù)組不變
splice() ----------------------從數(shù)組中添加/刪除項目，然后返回被刪除的項目，改變原數(shù)組
indexOf() -------------------從數(shù)組第0項查找目標(biāo)值，返回第一個值的下標(biāo)，無返回-1
lastIndexOf() ---------------從數(shù)組最后查找目標(biāo)值，返回第一個值的下標(biāo)，無返回-1
every() ----------------------數(shù)組中全部符合條件，返回true ，適用全選和取消全選的功能
some() ----------------------數(shù)組中有一個符合條件，返回true
includes() -------------------判斷數(shù)組是否包含指定的值 , 包含返回true , 否則返回false
reduce() --------------------常見用法可用于數(shù)組項求和、求最大值、去重
reduceRight() -------------用法同reduce(),只是遍歷的順序相反，從后向前
find() -------------------------遍歷數(shù)組，返回符合條件的第一個值 , 無返回undefined
filter() ------------------------遍歷數(shù)組，返回符合條件的數(shù)組，無則返回空數(shù)組
map() -----------------------遍歷數(shù)組，返回一個新數(shù)組，不改變原數(shù)組
forEach() -------------------遍歷數(shù)組，對數(shù)組中的每一個元素執(zhí)行一次回調(diào)函數(shù)，無返回值
for in -------------------------一般常用來遍歷對象或json
for of -------------------------數(shù)組對象都可以遍歷，遍歷對象需要通過和Object.keys()
for in -------------------------循環(huán)出的是key，for of循環(huán)出的是value

下面詳細(xì)介紹一下各個方法的基本功能

1.join()

join(separator): 將數(shù)組的元素組起一個字符串，以separator為分隔符，省略的話則用默認(rèn)用逗號為分隔符，該方法只接收一個參數(shù)：即分隔符。

var arr = [1,2,3];
console.log(arr.join()); // 1,2,3
console.log(arr.join("-")); // 1-2-3
console.log(arr); // [1, 2, 3]（原數(shù)組不變）

split() 方法用于把一個字符串分割成字符串?dāng)?shù)組。

var str='a,b,c,d'
var arr=str.split(',')   //使用','作為分隔符
console.log(arr)  // ["a", "b", "c", "d"]

通過join()方法可以實現(xiàn)重復(fù)字符串，只需傳入字符串以及重復(fù)的次數(shù)，就能返回重復(fù)后的字符串，函數(shù)如下：

function repeatString(str, n) {
return new Array(n + 1).join(str);
}
console.log(repeatString("abc", 3)); // abcabcabc
console.log(repeatString("Hi", 5)); // HiHiHiHiHi

2、push()和pop()

push(): 可以接收任意數(shù)量的參數(shù)，把它們逐個添加到數(shù)組末尾，并返回修改后數(shù)組的長度。
pop()：數(shù)組末尾移除最后一項，減少數(shù)組的 length 值，然后返回移除的項。

var arr = ["Lily","lucy","Tom"];
var count = arr.push("Jack","Sean");
console.log(count); // 5
console.log(arr); // ["Lily", "lucy", "Tom", "Jack", "Sean"]
var item = arr.pop();
console.log(item); // Sean
console.log(arr); // ["Lily", "lucy", "Tom", "Jack"]

3、shift() 和 unshift()

shift()：刪除原數(shù)組第一項，并返回刪除元素的值；如果數(shù)組為空則返回undefined 。
unshift:將參數(shù)添加到原數(shù)組開頭，并返回數(shù)組的長度 。

這組方法和上面的push()和pop()方法正好對應(yīng)，一個是操作數(shù)組的開頭，一個是操作數(shù)組的結(jié)尾。

var arr = ["Lily","lucy","Tom"];
var count = arr.unshift("Jack","Sean");
console.log(count); // 5
console.log(arr); //["Jack", "Sean", "Lily", "lucy", "Tom"]
var item = arr.shift();
console.log(item); // Jack
console.log(arr); // ["Sean", "Lily", "lucy", "Tom"]

4、sort()

sort()：按升序排列數(shù)組項——即最小的值位于最前面，最大的值排在最后面。

在排序時，sort()方法會調(diào)用每個數(shù)組項的 toString()轉(zhuǎn)型方法，然后比較得到的字符串，以確定如何排序。即使數(shù)組中的每一項都是數(shù)值， sort()方法比較的也是字符串，因此會出現(xiàn)以下的這種情況

var arr1 = ["a", "d", "c", "b"];
console.log(arr1.sort()); // ["a", "b", "c", "d"]
arr2 = [13, 24, 51, 3];
console.log(arr2.sort()); // [13, 24, 3, 51]
console.log(arr2); // [13, 24, 3, 51](元數(shù)組被改變)

為了解決上述問題，sort()方法可以接收一個比較函數(shù)作為參數(shù)，以便我們指定哪個值位于哪個值的前面。比較函數(shù)接收兩個參數(shù)，如果第一個參數(shù)應(yīng)該位于第二個之前則返回一個負(fù)數(shù)，如果兩個參數(shù)相等則返回 0，如果第一個參數(shù)應(yīng)該位于第二個之后則返回一個正數(shù)。以下就是一個簡單的比較函數(shù)：

function compare(value1, value2) {
if (value1 < value2) {
return -1;
} else if (value1 > value2) {
return 1;
} else {
return 0;
}
}
arr2 = [13, 24, 51, 3];
console.log(arr2.sort(compare)); // [3, 13, 24, 51]

如果需要通過比較函數(shù)產(chǎn)生降序排序的結(jié)果，只要交換比較函數(shù)返回的值即可：

function compare(value1, value2) {
if (value1 < value2) {
return 1;
} else if (value1 > value2) {
return -1;
} else {
return 0;
}
}
arr2 = [13, 24, 51, 3];
console.log(arr2.sort(compare)); // [51, 24, 13, 3]

5、reverse()

reverse()：反轉(zhuǎn)數(shù)組項的順序。

var arr = [13, 24, 51, 3];
console.log(arr.reverse()); //[3, 51, 24, 13]
console.log(arr); //[3, 51, 24, 13](原數(shù)組改變)

6、concat()

concat() ：將參數(shù)添加到原數(shù)組中。這個方法會先創(chuàng)建當(dāng)前數(shù)組一個副本，然后將接收到的參數(shù)添加到這個副本的末尾，最后返回新構(gòu)建的數(shù)組。在沒有給 concat()方法傳遞參數(shù)的情況下，它只是復(fù)制當(dāng)前數(shù)組并返回副本。

var arr = [1,3,5,7];
var arrCopy = arr.concat(9,[11,13]);
console.log(arrCopy); //[1, 3, 5, 7, 9, 11, 13]
console.log(arr); // [1, 3, 5, 7](原數(shù)組未被修改)

從上面測試結(jié)果可以發(fā)現(xiàn)：傳入的不是數(shù)組，則直接把參數(shù)添加到數(shù)組后面，如果傳入的是數(shù)組，則將數(shù)組中的各個項添加到數(shù)組中。但是如果傳入的是一個二維數(shù)組呢？

var arrCopy2 = arr.concat([9,[11,13]]);
console.log(arrCopy2); //[1, 3, 5, 7, 9, Array[2]]
console.log(arrCopy2[5]); //[11, 13]

7、slice()

slice()：返回從原數(shù)組中指定開始下標(biāo)到結(jié)束下標(biāo)之間的項組成的新數(shù)組。slice()方法可以接受一或兩個參數(shù)，即要返回項的起始和結(jié)束位置。在只有一個參數(shù)的情況下， slice()方法返回從該參數(shù)指定位置開始到當(dāng)前數(shù)組末尾的所有項。如果有兩個參數(shù)，該方法返回起始和結(jié)束位置之間的項——但不包括結(jié)束位置的項(含頭不含尾)

var arr = [1,3,5,7,9,11];
var arrCopy = arr.slice(1);
var arrCopy2 = arr.slice(1,4);
var arrCopy3 = arr.slice(1,-2);
var arrCopy4 = arr.slice(-4,-1);
console.log(arr); //[1, 3, 5, 7, 9, 11](原數(shù)組沒變)
console.log(arrCopy); //[3, 5, 7, 9, 11]
console.log(arrCopy2); //[3, 5, 7]
console.log(arrCopy3); //[3, 5, 7]
console.log(arrCopy4); //[5, 7, 9]

8、splice()

splice()：很強(qiáng)大的數(shù)組方法，它有很多種用法，可以實現(xiàn)刪除、插入和替換。

刪除：可以刪除任意數(shù)量的項，只需指定 2 個參數(shù)：要刪除的第一項的位置和要刪除的項數(shù)。例如， splice(0,2)會刪除數(shù)組中的前兩項。

插入：可以向指定位置插入任意數(shù)量的項，只需提供 3 個參數(shù)：起始位置、 0（要刪除的項數(shù)）和要插入的項。例如，splice(2,0,4,6)會從當(dāng)前數(shù)組的位置 2 開始插入4和6。
替換：可以向指定位置插入任意數(shù)量的項，且同時刪除任意數(shù)量的項，只需指定 3 個參數(shù)：起始位置、要刪除的項數(shù)和要插入的任意數(shù)量的項。插入的項數(shù)不必與刪除的項數(shù)相等。例如，splice (2,1,4,6)會刪除當(dāng)前數(shù)組位置 2 的項，然后再從位置 2 開始插入4和6。

splice()方法始終都會返回一個數(shù)組，該數(shù)組中包含從原始數(shù)組中刪除的項，如果沒有刪除任何項，則返回一個空數(shù)組。

var arr = [1,3,5,7,9,11];
var arrRemoved = arr.splice(0,2);
console.log(arr); //[5, 7, 9, 11]
console.log(arrRemoved); //[1, 3]
var arrRemoved2 = arr.splice(2,0,4,6);
console.log(arr); // [5, 7, 4, 6, 9, 11]
console.log(arrRemoved2); // []
var arrRemoved3 = arr.splice(1,1,2,4);
console.log(arr); // [5, 2, 4, 4, 6, 9, 11]
console.log(arrRemoved3); //[7]

9、indexOf()和 lastIndexOf()

indexOf()：接收兩個參數(shù)：要查找的項和（可選的）表示查找起點位置的索引。其中， 從數(shù)組的開頭（位置 0）開始向后查找。
lastIndexOf：接收兩個參數(shù)：要查找的項和（可選的）表示查找起點位置的索引。其中， 從數(shù)組的末尾開始向前查找。

這兩個方法都返回要查找的項在數(shù)組中的位置，或者在沒找到的情況下返回?1。在比較第一個參數(shù)與數(shù)組中的每一項時，會使用全等操作符。

var arr = [1,3,5,7,7,5,3,1];
console.log(arr.indexOf(5)); //2
console.log(arr.lastIndexOf(5)); //5
console.log(arr.indexOf(5,2)); //2
console.log(arr.lastIndexOf(5,4)); //2
console.log(arr.indexOf("5")); //-1

10、every()

every()：判斷數(shù)組中每一項都是否滿足條件，只有所有項都滿足條件，才會返回true。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.every(function(x) {
return x < 10;
}); 
console.log(arr2); //true
var arr3 = arr.every(function(x) {
return x < 3;
}); 
console.log(arr3); // false

11、some()

some()：判斷數(shù)組中是否存在滿足條件的項，只要有一項滿足條件，就會返回true。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.some(function(x) {
return x < 3;
}); 
console.log(arr2); //true
var arr3 = arr.some(function(x) {
return x < 1;
}); 
console.log(arr3); // false

12、includes()

該方法返回一個布爾值，表示某個數(shù)組是否包含給定的值，與字符串的includes方法類似。該方法屬于 ES7 ，但 Babel 轉(zhuǎn)碼器已經(jīng)支持

[1, 2, 3].includes(2); // true
 
[1, 2, 3].includes(4); // false
 
[1, 2, NaN].includes(NaN); // true

該方法的第二個參數(shù)表示搜索的起始位置，默認(rèn)為 0 。如果第二個參數(shù)為負(fù)數(shù)，則表示倒數(shù)的位置，如果這時它大于數(shù)組長度（比如第二個參數(shù)為 -4 ，但數(shù)組長度為 3 ），則會重置為從 0 開始

[1, 2, 3].includes(3, 3); // false
 
[1, 2, 3].includes(3, -1); // true

13、reduce()和 reduceRight()

這兩個方法都會實現(xiàn)迭代數(shù)組的所有項，然后構(gòu)建一個最終返回的值。reduce()方法從數(shù)組的第一項開始，逐個遍歷到最后。而 reduceRight()則從數(shù)組的最后一項開始，向前遍歷到第一項。

//語法
arr.reduce(function(prev,cur,index,arr){
...
}, init);

其中，
arr 表示原數(shù)組；
prev 表示上一次調(diào)用回調(diào)時的返回值，或者初始值 init;
cur 表示當(dāng)前正在處理的數(shù)組元素；
index 表示當(dāng)前正在處理的數(shù)組元素的索引，若提供 init 值，則索引為0，否則索引為1；
init 表示初始值。
太多不怕，常用參數(shù)只有prev、cur

舉例：

//原始數(shù)組
var arr = [3,9,4,3,6,0,9];

a.求數(shù)組項之和

var sum = arr.reduce(function (prev, cur) {
    return prev + cur;
},0);

由于傳入了初始值0，所以開始時prev的值為0，cur的值為數(shù)組第一項3，相加之后返回值為3作為下一輪回調(diào)的prev值，然后再繼續(xù)與下一個數(shù)組項相加，以此類推，直至完成所有數(shù)組項的和并返回
下面代碼用reduce()實現(xiàn)數(shù)組求和，數(shù)組一開始加了一個初始值10。

b.求數(shù)組項最大值

var max = arr.reduce(function (prev, cur) {
    return Math.max(prev,cur);
});

由于未傳入初始值，所以開始時prev的值為數(shù)組第一項3，cur的值為數(shù)組第二項9，取兩值最大值后繼續(xù)進(jìn)入下一輪回調(diào)

c. 數(shù)組去重

var newArr = arr.reduce(function (prev, cur) {
    prev.indexOf(cur) === -1 && prev.push(cur);
    return prev;
},[]);

① 初始化一個空數(shù)組
② 將需要去重處理的數(shù)組中的第1項在初始化數(shù)組中查找，如果找不到（空數(shù)組中肯定找不到），就將該項添加到初始化數(shù)組中
③ 將需要去重處理的數(shù)組中的第2項在初始化數(shù)組中查找，如果找不到，就將該項繼續(xù)添加到初始化數(shù)組中
④ ……
⑤ 將需要去重處理的數(shù)組中的第n項在初始化數(shù)組中查找，如果找不到，就將該項繼續(xù)添加到初始化數(shù)組中
⑥ 將這個初始化數(shù)組返回

數(shù)組中的find、filter、forEach、map四個語法很相近，為了方便記憶，真正的掌握它們的用法，所以就把它們總結(jié)在一起嘍

14、find()：返回通過測試的數(shù)組的第一個元素的值

語法：array.find(function(value, index, arr),thisValue)

value:必須，代表當(dāng)前元素，其他四個參數(shù)都是可選，index代表當(dāng)前索引值，arr代表當(dāng)前的數(shù)組，thisValue代表傳遞給函數(shù)的值，一般用this值，如果這個參數(shù)為空，undefined會傳遞給this值

返回值：返回符合測試條件的第一個數(shù)組元素的值，如果沒有符合條件的則返回undefined。

var arr = [1,2,3,4,5,6,7];
 var ar = arr.find(function(elem){
     return elem>5;
 });
 console.log(ar);//6
console.log(arr);//[1,2,3,4,5,6,7]

//根據(jù)一個id篩選出對象數(shù)組中的一個對象
var arr=[{id:1,name:'張三'},{id:2,name:'李四'}]
  obj = arr.find((item) => { 
    return item.id=== 2; //篩選出匹配數(shù)據(jù)
  });
console.log(obj)  //{id:2,nameL:'李四'}

15、filter()：創(chuàng)建一個新數(shù)組，新數(shù)組中的元素是通過檢查指定數(shù)組中符合條件的所有元素

語法：array.filter(function(value, index, arr),thisValue)

value:必須，代表當(dāng)前元素，其他四個參數(shù)都是可選，index代表當(dāng)前索引值，arr代表當(dāng)前的數(shù)組，thisValue代表傳遞給函數(shù)的值，一般用this值，如果這個參數(shù)為空，undefined會傳遞給this值

返回值：返回數(shù)組，包含了符合條件的所有元素，如果沒有符合條件的則返回空數(shù)組

 var arr = [1,2,3,4,5,6,7];
 var ar = arr.filter(function(elem){
     return elem>5;
 });
 console.log(ar);//[6,7]
console.log(arr);//[1,2,3,4,5,6,7]

16、map()：返回一個新數(shù)組，數(shù)組中的元素為原始數(shù)組元素調(diào)用函數(shù)處理后的值，map()方法按照原始數(shù)組元素順序依次處理元素

語法：array.map(function(value, index, arr),thisValue)

value:必須，代表當(dāng)前元素，其他四個參數(shù)都是可選，index代表當(dāng)前索引值，arr代表當(dāng)前的數(shù)組，thisValue代表傳遞給函數(shù)的值，一般用this值，如果這個參數(shù)為空，undefined會傳遞給this值

返回值：返回一個新數(shù)組，數(shù)組中的元素為原始數(shù)組元素調(diào)用函數(shù)處理后的值

var arr = [1,2,3,4,5,6,7];
 var ar = arr.map(function(elem){
    return elem*4;
 });
 console.log(ar);//[4, 8, 12, 16, 20, 24, 28]
console.log(arr);//[1,2,3,4,5,6,7]

17、forEach()：用于調(diào)用數(shù)組每個元素，并將元素傳遞給回調(diào)函數(shù)（注意沒有辦法跳出或終止forEach語句，除非拋出異常）

語法：array.forEach(function(value, index, arr),thisValue)

value:必須，代表當(dāng)前元素，其他四個參數(shù)都是可選，index代表當(dāng)前索引值，arr代表當(dāng)前的數(shù)組，thisValue代表傳遞給函數(shù)的值，一般用this值，如果這個參數(shù)為空，undefined會傳遞給this值

返回值：undefined

var arr = [1,2,3,4,5,6,7];
 var sum = 0;
 var ar = arr.forEach(function(elem){
    sum+=elem*4;
 });
 console.log(ar);//undefined
 console.log(arr);//[1,2,3,4,5,6,7]
 console.log(sum);//112

// 只傳一個匿名函數(shù)
arr.forEach(function(item,index,array){
    console.log(this);  // window
});

// 傳兩個參數(shù)
arr.forEach(function(item,index,array){
    console.log(this);  // [1,2,3,4,5,6,7]
},arr);

從上面的內(nèi)容我們可以看出，上面的四個語法以及參數(shù)的意義是一樣的，而且都不會對空數(shù)組進(jìn)行檢測，也不會改變原始數(shù)組
find()方法主要用來返回數(shù)組中符合條件的第一個元素（沒有的話，返回undefined）
filter()方法主要用來篩選數(shù)組中符合條件的所有元素，并且放在一個新數(shù)組中，如果沒有，返回一個空數(shù)組
map()方法主要用來對數(shù)組中的元素調(diào)用函數(shù)進(jìn)行處理，并且把處理結(jié)果放在一個新數(shù)組中返回（如果沒有返回值，新數(shù)組中的每一個元素都為undefined）
forEach()方法也是用于對數(shù)組中的每一個元素執(zhí)行一次回調(diào)函數(shù)，但它沒有返回值（或者說它的返回值為undefined，即便我們在回調(diào)函數(shù)中寫了return語句，返回值依然為undefined）

后期會繼續(xù)補(bǔ)充添加

拓展：
JS常用功能代碼片段