实现数组去重方法整理

1.双循环去重

双重for（或while）循环是比较早的方法，如果数组长度很大，那么将会非常耗费内存

    function setArray(arr) {
    if (Array.isArray(arr)) {
        let res = [arr[0]]
	    for (let i = 1; i < arr.length; i++) {
	        let flag = true
	        for (let j = 0; j < res.length; j++) {
	            if (arr[i] === res[j]) {
	                flag = false;
	                break
	            }
	        }
	        if (flag) {
	            res.push(arr[i])
	        }
	    }
	     return res
	    }
	}

2.indexOf方法去重

(1)该方法首先定义一个空数组res，然后调用indexOf方法对原来的数组进行遍历判断，如果元素不在res中，则将其push进res中,返回res

  function setArray1(arr) {
    if (Array.isArray(arr)) {
        let res = []
	    for (let i = 0; i < arr.length; i++) {
	        if (res.indexOf(arr[i]) === -1) {
	            res.push(arr[i])
	        }
	    }
	    return res
	    }
}

(2)利用indexOf检测元素在数组中第一次出现的位置是否和元素现在的位置相等，如果不等则说明该元素是重复元素

 function setArray2(arr) {
    if (Array.isArray(arr)) {
        return Array.prototype.filter.call(arr, function(item, index){
           return arr.indexOf(item) === index;
       });
    } 
}

3.相邻元素去重

先排序，然后根据排序后的结果进行遍历及相邻元素比对，如果相等则跳过改元素，直到遍历结束

 function setArray(arr) {
    if (Array.isArray(arr)) {
        arr = arr.sort()
	    let res = []
	    for (let i = 0; i < arr.length; i++) {
	        if (arr[i] !== arr[i-1]) {
	            res.push(arr[i])
	        }
	    }
	    return res
    }
}

4.利用对象属性去重

创建空对象，遍历数组，将数组中的值设为对象的属性，并给该属性赋初始值1，每出现一次，对应的属性值增加1，这样，属性值对应的就是该元素出现的次数了

  function setArray(arr) {
    if (Array.isArray(arr)) {
          let res = [],
          obj = {}
		  for (let i = 0; i < arr.length; i++) {
		      if (!obj[arr[i]]) {
		          res.push(arr[i])
		          obj[arr[i]] = 1
		      } else {
		          obj[arr[i]]++
		      }
		  }
		  return res
    }
}

5.new Set

new Set去重后，然后Array.from或者结构赋值将Set结构转换为数组

  function setArray(arr) {
    if (Array.isArray(arr)) {
       return [...new Set(arr)]
    }
    
}

或者

  function setArray(arr) {
    if (Array.isArray(arr)) {
      return Array.from(new Set(arr))
    }  
}

6.利用includes

  function setArray(arr){
      if(Array.isArray(arr)){
           var array =[];
		   for(var i =0; i <arr.length;i++){           
		       if(!array.includes(arr[i])){//includes 检测数组是否有某个值
		          array.push(arr[i]);
		       }
		    }
		return array
      }
} 
 //{}没有去重

7.利用filter

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

8.利用Map数据结构去重

  function setArray(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 ;
}

9.利用reduce

将需要去重处理的数组中的当前项在初始化数组中查找，如果找不到，就将该项继续添加到初始化数组中，返回初始化数组

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

当然，还有递归也可以实现，个人觉得没必要。