数组常用方法

数组

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()方法用于将一组数值转换为数组。

目的：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") // 注:localeCompare() 方法提供的比较字符串的方法，考虑了默认的本地排序规则。ECMAscript 标准并没有规定如何进行本地特定的比较操作，它只规定该函数采用底层操作系统提供的排序规则
})
//以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 concat()

作用：方法用于合并两个或多个数组，返回一个新数组。

参数：

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]
// 数组对象去重
  const obj = {};
      const newArr = this.checkedRowKeys.reduce((cur, next) => {
      obj[next.productCode] ? '' : (obj[next.productCode] = true && cur.push(next));
        return cur;
   }, []);

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))