JS- 数组去重方法整理

【indexOf】

简单而且可以加中文，但是兼容性不好，indexOF兼容到ie9

 function uniq(arr) {
     var temp = [];
     for (let i = 0; i < arr.length; i++) {
         if (temp.indexOf(arr[i]) == -1) {
             temp.push(arr[i])
         }
     }
     return temp;
 }
 console.log(uniq([1, 2, 3, 2, 34, "a", "b", "a", 2, 5, 2, 62, ]));

【排序后相邻去除法】

简单，去重排序一起做。但必须是纯数组，不能在数字中混入字符串

 function uniq3(array) {
   array.sort((a, b) => {
     return a - b
   });
   var temp = [array[0]]; //关键点，先把第一个放进去
   for (let i = 1; i < array.length; i++) { //i从1开始
     if (array[i] !== temp[temp.length - 1]) {
       temp.push(array[i])
     }
   }
   return temp;
 }
 console.log(uniq3([1, 2, 1, 2, 12, 13, 235, 3])); // 缺点就是不能加入字符串
 console.log(uniq3([1, 2, "b", 1, 2, 12, 13, 235, 3, "a"])); // 缺点就是不能加入字符串

【根据上边改成数组中字符串排序去重法】

 function uniq4(array) {
   array.sort((a, b) => {
     return (a+'').charCodeAt() - (b+'').charCodeAt()
   });
   var temp = [array[0]]; //关键点，先把第一个放进去
   for (let i = 1; i < array.length; i++) { //i从1开始
     if (array[i] !== temp[temp.length - 1]) {
       temp.push(array[i])
     }
   }
   return temp;
 }
 console.log(uniq4(['w', 'a', "b", 'w', 'n', 's', 's', 'b', 'e', "a"])); // 缺点就是不能混入别的

【存到对象里一一对比，去重无排序】

思路 - 利用对象的hash键值对方法，快速获取的特点

准备一个对象和一个新数组，

循环原数组时，将数组的值当做对象的键，且对应值为true（/1皆可），

然后每次拿原数组的下一个值都去判断一下对象中是否有这个值，

没有再push到新数组中去，最后返回新数组。

 uniqArr: function (arr) {
     var arr = Array.prototype.slice.call(arr),//这里防止伪数组，容错
         obj = {},
         newArr = [];
         obj[arr[0]] = true;//这里没必要
         newArr.push(arr[0]);
     arr.forEach((el) => {
         if (!obj[el]) {//但是这样写，又一个问题，见下边总结
             obj[el] = true;//这里写成true，if里少一步隐式转换
             newArr.push(el);
         }
     });
     return newArr;
 }

总结：

这种写法有一个问题，就是当我们arr中有多个不一样的对象元素（比如[1,{val:212},'a',{c: 1},false,{d:2}]这样时，会发现，只留下了第一个对象{val:212}这样。

控制台效果：

这是因为一个对象值当做obj的键名时会被toString化，得到的是obj['[object Object]']，后边再有对象时在forEach判断里条件不会成立，就不会被push到新数组，因此也就会被过滤掉了。

其原理同这个题：

 var a = {};b = {m: 1};c ={n:2};

 a[b] = 'b';

 a[c] = 'c';

a当中，键名不叫b也不叫c，而是b这个对象被Object.prototype.toString化后的字符串[object Object]。就是同一个原理。

因为我们使用[]来给对象a追加属性，在[]中，是期望是一个字符串类型的值，所以里边的值会被"字符串化"，

也就是当我们传的变量是一个{}时，对象会调用自身原型上的Object.prototype.toString进行转化变成字符串[object Object]。

当我们变量是一个数字12，会调用数字的构造类Number原型上重写的toString方法得到一个字符串'12'。

反正都是会转成字符串。即使当变量转为字符串后为特殊值（如NaN）等也不例外：

以上边的缺点引出下边的方法：

【一行代码实现数组去重】

 let newArr = [...new Set([1, 2, 23, 1, "gjf", 1, 6, "gjf","gfj"])]
 console.log(newArr)

// 核心

[…new Set([..需要去重的数组..])]

【缺点方法的解决】

上边说道【存到对象里，一一对比进行去重】方法时，有一个缺点是数组内嵌套了对象、数组这些值时，

因为obj[键值]会被字符串化，导致后边出现的多个对象都会被当做重复处理，

所以我们需要在往obj里存值时对这种情况进行一下处理

需要去重的数组：

先看最初的写法：

 function uniq0517(arr){
     var obj = {};
     var rst = [];
     arr.forEach(el => {
         if(!obj[el]){
             obj[el] = true;
             rst.push(el);
         }
     });
     console.log(obj);// 注意下打印的obj
     return rst;
 }

目标：去掉重复的对象和数组以及其他原始值，但是保留不同的对象和数组.

去重后的结果：

观察发现，除了对象外，都完成了很好的效果。

看打印的obj结果分析问题：

因为数组在obj的中括号[]里进行toString后是字符串'1,23,4'这样，所以可以比较不同。

但是对象不行。对象一律是[object Object]这样，需要对对象进行处理：

我的思路是，如果检测值为对象(就是普通的对象，而不是时间、正则等这种对象，

所以需要toString检测)时，就把这个对象先JSON.stringify化了。再去进行对比。

就像下面这样，JSON.stringify过后的对象绝对可以判断是否全等。

因此数组去重改造过后的代码如下：

 function uniq0517(arr){
     var obj = {},
         rst = [],
         tempEl = '';
     arr.forEach(el => {
         if(Object.prototype.toString.call(el) === '[object Object]'){
             // 证明这个值是一个对象，就事先将对象字符串化。而不是让他调用自己的toString
             tempEl = JSON.stringify(el);
         }else{
             // 其他类型的值时不做改变
             tempEl = el;
         }
         if(!obj[tempEl]){
             obj[tempEl] = true;
             rst.push(el);
         }
     });
     console.log(obj);
     return rst;
 }

完美经过检验！

最后拓展，想着把临时obj换成Map数据结构改造一下：

 function uni10519(arr){
     // 用Map实现去重 - 但凡引用值都不能去重
     let map = new Map(),
         rst = [];
     arr.forEach(el => {
         if(!map.get(el)){// 已有的一个对象再获取，因为地址不同，所以得到false
             map.set(el,true);
             rst.push(el);
         }
     });
     console.log(map);
     return rst;
 }
 console.log('map试水失败',uni10519(arr20190517));

算了吧。。。引用值地址不同，没法取出来作对比。

同样的，对于这种超级复杂类型的数组，进行去重的话，还得用我最原始的方式进行一一比对。否则set也扑街了：

 function uni10519Set(arr) {
     // 用Set实现去重
     return [...new Set(arr)];
 }
 console.log('set试水失败',uni10519Set(arr20190517));// 对象、数组什么的引用值都不能比较相等