史上最最最全的陣列方法（去重，查詢元素等）

阿新 • • 發佈：2020-12-08

技術標籤：javascript

陣列

1.陣列的建立

1.1字面量建立（常用）

var a = [3, 11, 8];

1.2 構造器

實際上 new Array === Array,加不加new 一點影響都沒有。

var a = Array(); // [] 
建立一個數據的陣列時出錯。
var a = Array(3); // [undefined,undefined,undefined]
var a = Array(3,11,8); // [ 3,11,8 ]

1.3 ES6建立陣列

定義：返回由所有引數值組成的陣列，如果沒有引數，就返回一個空陣列。

目的：Array.of() 出現的目的是為了解決上述構造器因引數個數不同，導致的行為有差異的問題。

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

2.類陣列轉換為陣列（Arrar.from()）

定義：用於將兩類物件轉為真正的陣列（不改變原物件，返回新的陣列）。

引數：

第一個引數(必需):要轉化為真正陣列的物件。

第二個引數(可選): 類似陣列的map方法，對每個元素進行處理，將處理後的值放入返回的陣列。

第三個引數(可選): 用來繫結this。

// 1. 物件擁有length屬性
let obj = {0: 'a', 1: 'b', 2:'c', length: 3};
let arr = Array.from 
(obj); // ['a','b','c'];
// 2. 部署了 Iterator介面的資料結構 比如:字串、Set、NodeList物件 Iterator是一個介面，為各種不同的資料結構提供統一的訪問機制，任何資料結構只要部署了Iterator介面，就可以完成遍歷操作。
let arr = Array.from('hello'); // ['h','e','l','l']
let arr = Array.from(new Set(['a','b'])); // ['a','b']  可以進行去重操作

3.改變原陣列的方法（9個）

ES5:
a.pop()/ a.shift()/ a.push()/ a.unshift 
()/ a.reverse()/ a.splice()/ a.sort() 
ES6:
a.copyWithin() / a.fill

ES5中：

3.1 pop()

作用：方法刪除一個數組中的最後的一個元素，並且返回這個元素。

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

3.2 shift()

作用：方法刪除陣列的第一個元素，並返回這個元素。

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

3.3 push()

作用：方法可向陣列的末尾新增一個或多個元素，並返回新的長度。

引數: item1, item2, …, itemX ,要新增到陣列末尾的元素

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

3.4 unshift()

作用：unshift() 方法可向陣列的開頭新增一個或更多元素，並返回新的長度。

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

3.5 reverse()

作用：reverse()方法用於顛倒陣列中元素的順序。

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

3.6 splice()

作用：陣列的刪除、新增、替換，會改變原陣列

3.6.1 刪除

引數：一個或兩個引數

(1)一個引數時：從下標為引數的位置開始刪除，一直刪除到最後

var arr = [1,2,3,4,5,6]
var n = arr.splice(1)
console.log(n)//[2,3,4,5,6]
console.log(arr)//[1]

(2)兩個引數時：陣列.splice(開始位置，刪除的位數)，當開始位置為負數時，從最後一位開始刪除。

var arr = [1,2,3,4,5,6]
var n = arr.splice(1,1)//從1的位置開始刪除，只刪除1個
console.log(n)//[2]
console.log(arr)//[1,3,4,5,6]

3.6.2 新增和替換

引數：至少3個

可以向指定位置插入任意數量的值，只需要提供3個引數：起始位置、要刪除的項數（單純新增時，此項為0，替換時填寫要替換的個數）、要插入的項。如果插入多個項，可以再傳入任意多個項。

新增：陣列.splice(start,0,陣列項1,陣列項2…)

var arr = [1,5,9]
arr.splice(1,0,4,6)//從1的位置新增4和6
console.log(arr)//[1,4,6,5,9]

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] 在最後一個元素的前面新增兩個元素

替換：

陣列.splice(start,刪除的位數，陣列項1，陣列項1…)

var arr = [1,4,6,5,9]
arr.splice(1,2,7,8,7)//從1的位置開始，刪除兩個陣列項，然後將7，8，7插入到這個位置
console.log(arr)//[1,7,8,7,5,9]

// 從陣列下標0開始，刪除3個元素，並新增元素'新增'
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]


//起始位置為負數：
// 從陣列最後第二個元素開始，刪除3個元素，並新增兩個元素'新增1'、'新增2'
 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.6.3總結

陣列如果元素不夠，會刪除到最後一個元素為止
操作的元素，包括開始的那個元素
可以新增很多個元素
新增是在開始的元素前面新增的

3.7 sort()

作用：sort()方法對陣列元素進行排序，並返回這個陣列

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

預設情況下sort()方法沒有傳比較函式的話，預設按字母升序，如果不是元素不是字串的話，會呼叫toString()方法將元素轉化為字串的Unicode(萬國碼)位點，然後再比較字元。

例：

var arr = [5,8,7,4,2,11,3,9,6]
arr.sort()//[11,2,3,4,5,6,7,8,9]//預設按照字串方法進行排序

3.7.1 自定義排序

var arr = [5,8,7,4,2,11,3,9,6]
arr.sort(function(a,b){//a,b分別代表相鄰的兩個陣列元素
    return a-b;//從小到大[2,3,4,5,6,7,8,9,11]
    return b-a;//從大到小[11,9,8,7,6,5,4,3,2]
})

3.7.2 根據物件的某個屬性進行排序

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

3.7.3 根據中文進行排序

a.name.localeCompare(b.name,“zh”)

var arr = [
{name:"武"，num:"78"},
{name:"湯"，num:"75"},
{name:"盧"，num:"35"},
{name:"鄧"，num:"12"},
{name:"劉"，num:"21"},
]
//以姓名排序
arr.sort(function(a,b){
    return a.name.localeCompare(b.name,"zh")
})
//以num排序
arr.sort(function(a,b){
    return a.num - b.num//從小到大

3.7.4 自定義比較函式

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

ES6中：

3.8 copyWithin()

作用：在當前陣列內部，將指定位置的成員複製到其他位置,並返回這個陣列。

引數:

三個引數都是數值，如果不是，會自動轉為數值.

target（必需）：從該位置開始替換資料。如果為負值，表示倒數。
start（可選）：從該位置開始讀取資料，預設為 0。如果為負值，表示倒數。
end（可選）：到該位置前停止讀取資料。使用負數可從陣列結尾處規定位置。

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

// -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"]

上述例子中，第一個容易理解，講解一下第二個：

（1）起始時：a=['OB1','Koro1','OB2','Koro2','OB3','Koro3','OB4','Koro4','OB5','Koro5']
（2）複製3-5位，不包括第五位，複製的為：['Koro2','OB3'],此時原陣列保持不辯，依然為a=['OB1','Koro1','OB2','Koro2','OB3','Koro3','OB4','Koro4','OB5','Koro5']
（3）替換，從第二位開始進行替換，複製出來的為兩項，要替換的應也為兩項，所以要替換的項時：['OB2','Koro2']
(4)進行替換，陣列就變成了a=['OB1','Koro1','Koro2','OB3','OB3','Koro3','OB4','Koro4','OB5','Koro5']

總結：

（1）第一個引數是開始被替換的元素位置
（2）要替換資料的位置範圍:從第二個引數是開始讀取的元素，在第三個引數前面一個元素停止讀取
（3）陣列的長度不會改變
（4）讀了幾個元素就從開始被替換的地方替換幾個元素

3.9 fill()

作用：使用給定值，填充一個數組。

引數:

第一個元素(必須): 要填充陣列的值

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

第三個元素(可選)：填充的結束位置，預設是為this.length

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

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill("Runoob", 2, 4);//Banana,Orange,Runoob,Runoob

4.不改變原陣列的方法（8個）

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

4.1 join()

作用：join()方法用於把陣列中的所有元素通過指定的分隔符進行分隔放入一個字串，返回生成的字串。

引數:

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

所以，join()/toString()方法在陣列元素是陣列的時候，會將裡面的陣列也呼叫join()/toString(),如果是物件的話，物件會被轉為[object Object]字串。

4.2 toLocaleString()

作用：返回一個表示陣列元素的字串。該字串由陣列中的每個元素的 toLocaleString() 返回值經呼叫 join() 方法連線（由逗號隔開）組成。

let a=[{name:'OBKoro1'},23,'abcd',new Date()];
let str=a.toLocaleString(); // [object Object],23,abcd,2018/5/28 下午1:52:20 
//join()/toString()方法在陣列元素是陣列的時候，會將裡面的陣列也呼叫join()/toString(),如果是物件的話，物件會被轉為[object Object]字串。

上述例子中：陣列中的每個元素都會呼叫自身的toLocaleString方法，物件呼叫物件的toLocaleString,Date呼叫Date的toLocaleString。

4.3toString()

作用：toString()方法可把陣列轉換為由逗號連結起來的字串。這種方法只是join方法的一部分功能，所以更推薦使用join方法。

let b= [ 'toString','演示'].toString(); // toString,演示
let a= ['呼叫toString','連線在我後面']+'啦啦啦'; 
let c = a.toString()// 呼叫toString,連線在我後面啦啦啦

4.4slice()

作用：方法返回一個從開始到結束（不包括結束）選擇的陣列的一部分淺拷貝到一個新陣列物件，且原陣列不會被修改。

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

引數：
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()是淺拷貝，對於複雜的資料型別淺拷貝，拷貝的只是指向原陣列的指標，所以無論改變原陣列，還是淺拷貝的陣列，都是改變原陣列的資料。

4.5 cancat()

作用：方法用於合併兩個或多個數組，返回一個新陣列。

引數：

arrayX（必須）：該引數可以是具體的值，也可以是陣列物件。可以是任意多個。

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 擴充套件運算子 …合併陣列

…運算子可以實現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]

4.6 indexOf()

返回在陣列中可以找到一個給定元素的第一個下標，如果不存在，則返回-1。

引數:

searchElement(必須):被查詢的元素
fromIndex(可選):開始查詢的位置(不能大於等於陣列的長度，返回-1)，接受負值，預設值為0。

注意：
陣列的indexOf搜尋跟字串的indexOf不一樣,陣列的indexOf使用嚴格相等===搜尋元素，即陣列元素要完全匹配才能搜尋成功。

let a=['啦啦',2,4,24,NaN]
console.log(a.indexOf('啦')); // -1 
console.log(a.indexOf('NaN')); // -1 
console.log(a.indexOf('啦啦')); // 0
//綜上：indexOf()不能識別NaN

4.7lastIndexOf()

作用：方法返回指定元素在陣列中的最後一個的索引，如果不存在則返回 -1。（從陣列後面往前查詢）

引數:
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

4.8 includes()

ES7的語法：返回一個布林值，表示某個陣列是否包含給定的值

相容性： chrome47, Firefox 43,Edge 14,Opera 34, Safari 9,IE 未實現。

引數：
searchElement(必須):被查詢的元素
fromIndex(可選):預設值為0，引數表示搜尋的起始位置，接受負值。正值超過陣列長度，陣列不會被搜尋，返回false。負值絕對值超過長陣列度，重置從0開始搜尋。

includes方法是為了彌補indexOf方法的缺陷而出現的:
indexOf方法不能識別NaN
indexOf方法檢查是否包含某個值不夠語義化，需要判斷是否不等於-1，表達不夠直觀

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 負值絕對值超過陣列長度，搜尋整個陣列

indexOf、lastIndexOf、includes總結：

1、indexOf、lastIndexOf返回值為下標，includes返回值為true或false
2、indexOf 開始查詢位置大於等於陣列長度時，返回-1，陣列不會被查詢
3、lastIndexOf 開始查詢位置數值為負數且其絕對值大於陣列長度，則方法返回 -1，即陣列不會被查詢。
4、lastIndexOf  開始查詢位置數值為正值且該值大於或等於陣列的長度，則整個陣列會被查詢。逆向查詢
5、includes 正值超過陣列長度，陣列不會被搜尋，返回false。負值絕對值超過長陣列度，重置從0開始搜尋。

5.陣列的遍歷方法

js中遍歷陣列並不會改變原始陣列的方法總共有12個:
ES5：
forEach、every 、some、 fliter、map、reduce、reduceRight、
ES6：
find、findIndex、keys、values、entries

5.1 forEach()

作用：按升序為陣列中含有效值的每一項執行一次回撥函式。（元素為空時，不是有效值）

注意：

***無法中途退出迴圈，只能用return退出本次回撥，進行下一次回撥。
***它總是返回 undefined值,即使你return了一個值。
對於空陣列是不會執行回撥函式的
對於已在迭代過程中刪除的元素，或者空元素會跳過回撥函式
遍歷次數再第一次迴圈前就會確定，再新增到陣列中的元素不會被遍歷。
如果已經存在的值被改變，則傳遞給 callback 的值是遍歷到他們那一刻的值。

語法：

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

引數：

第一個引數：function(必須): 陣列中每個元素需要呼叫的函式。

// 回撥函式的引數
1. currentValue(必須),陣列當前元素的值
2. index(可選), 當前元素的索引值
3. arr(可選),陣列物件本身

第二個引數：thisValue(可選): 當執行回撥函式時this繫結物件的值，預設值為undefined

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，只打印一個undefined
// 回撥函式也接受接頭函式寫法

5.2 every()

作用：方法用於檢測陣列所有元素是否都符合函式定義的條件

引數、語法與forEach引數相同

規則：

如果陣列中檢測到有一個元素不滿足，則整個表示式返回 false，且剩餘的元素不會再進行檢測。
如果所有元素都滿足條件，則返回 true。

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

5.3 some ()

作用：陣列中的是否有滿足判斷條件的元素

引數、語法與forEach引數相同

規則：

如果有一個元素滿足條件，則表示式返回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

5.4 filter ()

作用：返回一個新陣列, 其包含通過所提供函式實現的測試的所有元素。不會改變原陣列

引數、語法與forEach引數相同

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]

5.5 map ()

作用：建立一個新陣列，其結果是該陣列中的每個元素都呼叫一個提供的函式後返回的結果。

引數、語法與forEach引數相同

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

5.6reduce ()

作用：為陣列提供累加器，合併為一個值，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 但陣列為空，那麼回撥不會被執行，陣列的唯一值將被返回。

// 陣列求和 
let sum = [0, 1, 2, 3].reduce(function (a, b) {
 return a + b;
}, 0);
// 6
// 將二維陣列轉化為一維 將陣列元素展開
//講解：初始initialValue被提供，那麼此時a為[],b為第一個元素即[0, 1]，依次執行，就會將元素展開
let flattened = [[0, 1], [2, 3], [4, 5]].reduce(
 (a, b) => a.concat(b),
 []
);
 // [0, 1, 2, 3, 4, 5]

5.7 reduceRight ()

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

5.8 find()& findIndex()

ES6語法瀏覽器相容(MDN):Chrome 45,Firefox 25,Opera 32, Safari 8, Edge yes,

作用：

（1）find()定義：用於找出第一個符合條件的陣列成員，並返回該成員，如果沒有符合條件的成員，則返回undefined。

（2）findIndex()定義：返回第一個符合條件的陣列成員的位置，如果所有成員都不符合條件，則返回-1。

引數、語法與forEach引數相同並且這兩個方法都可以識別NaN,彌補了indexOf的不足.

// 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  Object.is(value1,value2)判斷兩個值是否相等，返回值為true或者false
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

5.9 keys()&values()&entries()

遍歷鍵名、遍歷鍵值、遍歷鍵名+鍵值三個方法都返回一個新的 Array Iterator 物件，物件根據方法不同包含不同的值。

語法：注意在物件中也有這幾個方法，用法不同，注意區分

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

//遍歷鍵名，實際上是遍歷下標
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)//Object [Array Iterator] {}
console.log(entries.next().value); // [0, 'a']
console.log(entries.next().value); // [1, 'b']
console.log(entries.next().value); // [2, 'c']

6.陣列去重

6.1 利用ES6 Set去重

注意：不考慮相容性，這種去重的方法程式碼最少。這種方法還無法去掉“{}”空物件

function unique (arr) {
  return Array.from(new Set(arr))
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))
 //[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {}, {}]

6.2 for迴圈巢狀，利用splice去重

原理：雙層迴圈，外層迴圈元素，內層迴圈時比較值。值相同時，則刪去這個值。

//[1, "true", 15, false, undefined, NaN, NaN, "NaN", "a", {}, {}]     //NaN和{}沒有去重
function unique(arr){            
        for(var i=0; i<arr.length; i++){
            for(var j=i+1; j<arr.length; j++){
                if(arr[i]===arr[j]){         //第一個等同於第二個，splice方法刪除第二個
                    arr.splice(j,1);
                    j--;
                }
            }
        }
return arr;
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
    console.log(unique(arr))

6.3 利用indexOf去重

原理：新建一個空的結果陣列，for 迴圈原陣列，判斷結果陣列是否存在當前元素，如果有相同的值則跳過，不相同則push進陣列。

   // [1, "true", true, 15, false, undefined, null, NaN, NaN, "NaN", 0, "a", {}, {}]  //NaN、{}沒有去重
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    var array = [];
    for (var i = 0; i < arr.length; i++) {
        if (array .indexOf(arr[i]) === -1) {
            array .push(arr[i])
        }
    }
    return array;
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))

6.4 sort()方法去重

原理：利用sort()排序方法，然後根據排序後的結果進行遍歷及相鄰元素比對。

// [0, 1, 15, "NaN", NaN, NaN, {…}, {…}, "a", false, null, true, "true", undefined]      //NaN、{}沒有去重
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return;
    }
    arr = arr.sort()
    var arrry= [arr[0]];
    for (var i = 1; i < arr.length; i++) {
        if (arr[i] !== arr[i-1]) {
            arrry.push(arr[i]);
        }
    }
    return arrry;
}
     var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
        console.log(unique(arr))

6.5 includes方法去重

原理：新建一個空的結果陣列，for 迴圈原陣列，判斷結果陣列是否存在當前元素，如果有相同的值則跳過，不相同則push進陣列。

//[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {}, {}]   //{}沒有去重
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    var array =[];
    for(var i = 0; i < arr.length; i++) {
            if( !array.includes( arr[i]) ) {//includes 檢測陣列是否有某個值
                    array.push(arr[i]);
              }
    }
    return array
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
    console.log(unique(arr))

6.6 hasOwnProperty方法去重

原理：利用hasOwnProperty 判斷是否存在物件屬性，陣列項為物件時，此方法不適用

function unique(arr) {
    var obj = {};
    return arr.filter(function(item, index, arr){
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
    })
}
    var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
        console.log(unique(arr))
//[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {…}]   //所有的都去重了

6.7 filter方法去重

原理：當前元素，在原始陣列中的第一個下標==當前下標，則返回當前元素，否則不返回

//[1, "true", true, 15, false, undefined, null, "NaN", 0, "a", {}, {}]  {}沒有去重
function unique(arr) {
  return arr.filter(function(item, index, arr) {
    //當前元素，在原始陣列中的第一個索引==當前索引值，否則返回當前元素
    return arr.indexOf(item, 0) === index;
  });
}
 var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))

6.8 利用遞迴去重

原理：先對陣列進行排序，去重更加方便。然後遞迴進行後一項和前一項的比較，如果相等，則利用splice方法刪除其中一項，不相等則進行下一次比較。最先是從最後一項和倒數第二項進行比較。

//[1,'true',false, null,0,true,15, NaN,NaN,'NaN','a',{},{},undefined]   NaN和{}不會去重
function unique(arr) {
        var array= arr;
        var len = array.length;

    array.sort(function(a,b){   //排序後更加方便去重
        return a - b;
    })

    function loop(index){
        if(index >= 1){
            if(array[index] === array[index-1]){
                array.splice(index,1);
            }
            loop(index - 1);    //遞迴loop，然後陣列去重
        }
    }
    loop(len-1);
    return array;
}
 var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))

6.9 利用Map資料結構去重

//[1, 'true',true,  15,false, undefined,null,  NaN,'NaN', 0,'a',{},{}] {}不會進行去重
function arrayNonRepeatfy(arr) {
  let map = new Map();
  let array = new Array();  // 陣列用於返回結果
  for (let i = 0; i < arr.length; i++) {
    if(map .has(arr[i])) {  // 如果有該key值
      map.set(arr[i], true); 
    } else { 
      map .set(arr[i], false);   // 如果沒有該key值
      array .push(arr[i]);
    }
  } 
  return array ;
}
 var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
    console.log(arrayNonRepeatfy(arr))

6.10 利用reduce+includes

function unique(arr){
    return arr.reduce((prev,cur) => prev.includes(cur) ? prev : [...prev,cur],[]);
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr));
// [1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {}, {}]

6.11 […new Set(arr)]

//[1,'true',true,  15,false, undefined,null,  NaN,'NaN', 0,'a',{},{}]  {}不會去重
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log([...new Set(arr)] )

6.12 對引用型別也進行了去重

因為 NaN 不等於任何數值，包括自身也是不相等：NaN == NaN // false NaN === NaN // false
所以才會導致 NaN 沒有被去重。

// [1, "true", true, 15, false, undefined, null, NaN, NaN, "NaN", 0, "a",{}, {a:1}, {b:1}]
function unique6 (arr) {
  let newArr = []
  let obj = {}
  arr.forEach(item => {
    if (typeof item !== 'object') {
      if (newArr.indexOf(item) === -1) {
        newArr.push(item)
      }
    } else {
      let str = JSON.stringify(item)
      if (!obj[str]) {
        newArr.push(item)
        obj[str] = 1
      }
    }
  })
  return newArr
}
let arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{},{a:1},{b:1},{a:1}]
console.log(unique6(arr))