数组去重的12重方法

1.利用ES6 Set去重（ES重最常用)

function unique(arr){
    return Array.from(new Set(arr));
}

这种去重的方法代码最少。这种方法无法去掉{}空对象，后面的高阶方法会添加去重复{}的方法。

2.利用for嵌套，然后splice去重（ES5重常见）

function unique(arr){
   for(var i=0;i<arr.length;i++){
      for(var j=0;j<arr.length;j++){{
          if(arr[i] === arr[j]){
              arr.splice(j,1);
              j--;
          }
       }
    }
}

双层循环，外层循环元素，内存循环比较值。值相同时，则删除这个值。

3.利用indexOf去重

function unique(arr){
   if(!Array.isArray(arr)){
      console.log('typr error')
      return 
   }
   var array = [];
   for(var i=0;i<arr.length;i++){
     if(array.indexOf(arr[i] === -1){
       array.push(arr[i])
     }
   }
   return array;
}

创建一个空的结果数组，for循环原数组，判断结果数组是否在当前元素，如果有相同的值则跳过，不相同则push进新数组。

4.利用sort()

function unique(arr){
	if(!Array.isArray(arr)){
	      console.log('typr error')
	      return 
	}
	arr = arr.sort() // 进行排序
	var array = [arr[0]];
	for(var i=1;i<arr.length;i++){
	   if(arr[i]!==arr[i-1])
	     array.push(arr[i]);
	}
	return array;
}

利用sort()方法，然后根据排序后的结果进行遍历及相邻元素比对。

5. 利用对象属性不能相同的特性进行去重（这个的方法有问题，不建议使用）

关键代码：

var array = [];
var obj = {};
for(var i=0; i<arr.length;i++){
  if(!obj[arr[i]]){
     array.push(arr[i]);
     obj[arr[i]] = 1;
  }else{
      obj[arr[i]] ++;
  }
}

6.利用includes

function unique(arr){
	if(!Array.isArray(arr)){
	      console.log('typr error')
	      return 
	}
	var array = [];
	for(var i=0;i<arr.length;i++){
	  if(!array.includes(arr[i]){
	     // includes检测数组是否有某值
	     array.push(arr[i])
	  }
	}
	return array;
}

7.利用hasProperty

hasProperty判断是否在对象属性。

function unique(arr) {
 let obj = {}
 let res = arr.filter(item => {
   if (obj.hasOwnProperty(typeof item + item)) {
     return false
   } else {
     obj[typeof item + item] = true
     return true
   }
  })
  return res
}

8.利用filter

function unique(arr){
  return arr.filter( function(item,index,arr){
     // 当前元素，在原始数组重第一个索引 == 当前索引值，否则返回当前元素
      return arr.indexOf( item,0 ) == index;
  })
}

9.利用递归去重

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.aplice(index,1);
        }
        loop(index-1);
     }
   }
   loop(len-1);
   return array;
}

10.利用Map数据结构去重

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);
        array.push(arr[i]);
     }
   }
}

创建一个空Map数据结构，遍历需要去重的数组，把数组的每个元素作为key存到Map重。由于Map中不会出现相同的值，所以最终得到的就是去重后的结果。

11.利用reduce+includes

function unique(arr){
  return arr.reduce((prev,cur)=>prev.includes(cur) ? [...prev,cur],[]);
}

12. […new Set(arr)]

第一种方法的简化