数组去重的方法

一、第一种去重

利用双重for循环

var arr = [0,0,'a','a','true','true','false','false',true,true,false,false,null,null,undefined,undefined,NaN,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;
}
console.log(arr);
console.log(unique(arr));

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

NAN和空对象没有去重，false和undefined直接消失了

二、第二种去重 利用ES6 Set去重

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

三、第三种利用indexOf去重

var arr = [0,0,'a','a','true','true','false','false',true,true,false,false,null,null,undefined,undefined,NaN,NaN,[],[],{},{}]
function unique(arr) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        if (newArr.indexOf(arr[i]) === -1) {
            newArr.push(arr[i])
        }
    }
    return newArr;
}
console.log(arr);
console.log(unique(arr));

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

四、利用sort()

var arr = [0,0,'a','a','true','true','false','false',true,true,false,false,null,null,undefined,undefined,NaN,NaN,[],[],{},{}]
function unique(arr) {
    arr = arr.sort()
    var newArr= [arr[0]];
    for (var i = 1; i < arr.length; i++) {
        if (arr[i] !== arr[i-1]) {
            newArr.push(arr[i]);
        }
    }
    return newArr;
}
console.log(arr);
console.log(unique(arr));

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

五、利用对象的属性不能相同的特点进行去重

var arr = [0,0,'a','a','true','true','false','false',true,true,false,false,null,null,undefined,undefined,NaN,NaN,[],[],{},{}]
function unique(arr) {
    var newArr= [];
     var  obj = {};
    for (var i = 0; i < arr.length; i++) {
        if (!obj[arr[i]]) {
            newArr.push(arr[i])
            obj[arr[i]] = 1
        } else {
            obj[arr[i]]++
        }
    }
    return newArr;
}
console.log(arr);
console.log(unique(arr));

六、利用includes

var arr = [0,0,'a','a','true','true','false','false',true,true,false,false,null,null,undefined,undefined,NaN,NaN,[],[],{},{}]
function unique(arr) {
    var newArr =[];
    for(var i = 0; i < arr.length; i++) {
            if( !newArr.includes( arr[i]) ) {//includes 检测数组是否有某个值
                    newArr.push(arr[i]);
              }
    }
    return newAr
}
console.log(arr);
console.log(unique(arr));

七、利用hasOwnProperty

var arr = [0,0,'a','a','true','true','false','false',true,true,false,false,null,null,undefined,undefined,NaN,NaN,[],[],{},{}]
function unique(arr) {
    var obj = {};
    return arr.filter(function(item, index, arr){
        return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)
    })
}
console.log(arr);
console.log(unique(arr));

利用hasOwnProperty 判断是否存在对象属性

八、利用filter

var arr = [0,0,'a','a','true','true','false','false',true,true,false,false,null,null,undefined,undefined,NaN,NaN,[],[],{},{}]
function unique(arr) {
   let newArr = arr.filter(function(item, index) {
      //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
      return arr.indexOf(item) === index;
    });
    return(newArr);
  }
console.log(arr);
console.log(unique(arr));

九、利用递归去重

var arr = [0,0,'a','a','true','true','false','false',true,true,false,false,null,null,undefined,undefined,NaN,NaN,[],[],{},{}]
function unique(arr) {
  var newArr = arr;
  var len = newArr.length;

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

  function loop(index) {
    if (index >= 1) {
      if (newArr[index] === newArr[index - 1]) {
        newArr.splice(index, 1);
      }
      loop(index - 1); //递归loop，然后数组去重
    }
  }
  loop(len - 1);
  return newArr;
}
console.log(arr);
console.log(unique(arr));

十、利用Map数据结构去重

var arr = [0,0,'a','a','true','true','false','false',true,true,false,false,null,null,undefined,undefined,NaN,NaN,[],[],{},{}]
function unique(arr) {
    let map = new Map();
    let newArr = [];  // 数组用于返回结果
    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值
        newArr .push(arr[i]);
      }
    } 
    return newArr ;
  }
console.log(arr);
console.log(unique(arr));

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

十一、利用reduce+includes

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

十二、[…new Set(arr)]

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