js中常见数组去重方法

数组去重的方法

一、利用ES6 Set去重（ES6中最经常使用）数组

var arr = [1,1,'true','true',true,true,15,15,false,false, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{ },{ }];

function unique (arr) { 
      return Array.from(new Set(arr)) //Set()方法打印出来是个没有重复值的对象，因此要用Array.from方法把它转成数组后返回
}
console.log(unique(arr))
//运行结果：
//[1, "true", true, 15, false, null, NaN, "NaN", 0, "a", {}, {}]

//简写：
let arr1 = [...new Set(arr)]
console.log(arr1);

//扩展：将任意个数组合并，并去重
function merge() { 
    return Array.from(new Set(arguments[0].concat(...arguments)))
}
console.log(merge([1, 2, 3, 4], [5, 6, 1, 2], [5, 6, 7, 8, 9]))

//运行结果：
//[ 1, 2, 3, 4, 5, 6, 7, 8, 9]

二、利用for嵌套for，而后splice去重（ES5中最经常使用）性能优化

var arr = [1,1,'true','true',true,true,15,15,false,false, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{ },{ }];

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(unique(arr))
//运行结果：
//[1, "true", true, 15, false, null, NaN, "NaN", 0, "a", {}, {}]

三、利用indexOf去重数据结构

var arr = [1,1,'true','true',true,true,15,15,false,false, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{ },{ }];

function unique(arr) { 
//性能优化，首先判断输入数据的类型，不是array，直接报错并返回
  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;
}
console.log(unique(arr))
//运行结果：
//[1, "true", true, 15, false, null, NaN, "NaN", 0, "a", {}, {}]

四、利用sort()去重性能

var arr = [1,1,'true','true',true,true,15,15,false,false, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{ },{ }];

function unique(arr) { 
//性能优化，首先判断输入数据的类型，不是array，直接报错并返回
  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;
}
console.log(unique(arr))
//运行结果：
//[1, "true", true, 15, false, null, NaN, "NaN", 0, "a", {}, {}]

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

var arr = [1,1,'true','true',true,true,15,15,false,false, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{ },{ }];

function unique(arr) { 
  if (!Array.isArray(arr)) { 
  //性能优化，首先判断输入数据的类型，不是array，直接报错并返回
    console.log('type error!')
    return
  }
  var arrry= [];
  var  obj = { };
  for (var i = 0; i < arr.length; i++) { 
    if (!obj[arr[i]]) { 
      arrry.push(arr[i])
      obj[arr[i]] = 1
    } else { 
      obj[arr[i]]++
    }
  }
  return arrry;
}
console.log(unique(arr))
//运行结果：
//[1, "true", true, 15, false, null, NaN, "NaN", 0, "a", {}, {}]

六、利用includes去重spa

var arr = [1,1,'true','true',true,true,15,15,false,false, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{ },{ }];

function unique(arr) { 
    //性能优化，首先判断输入数据的类型，不是array，直接报错
  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
}
console.log(unique(arr))
//运行结果：
//[1, "true", true, 15, false, null, NaN, "NaN", 0, "a", {}, {}]

七、利用hasOwnProperty去重code

var arr = [1,1,'true','true',true,true,15,15,false,false, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{ },{ }];

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(unique(arr))
//运行结果：
//[ 1, 'true', true, 15, false, null, NaN, 'NaN', 0, 'a', {} ]

八、利用filter去重对象

var arr = [1,1,'true','true',true,true,15,15,false,false, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{ },{ }];

function unique(arr) { 
      return arr.filter(function(item, index, arr) { 
        //当前元素，在原始数组中的第一个索引==当前索引值，不然返回当前元素
        return arr.indexOf(item, 0) === index;
      });
    }
console.log(unique(arr))
//运行结果：
//[ 1, 'true', true, 15, false, null, 'NaN', 0, 'a', {}, {} ]

九、利用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);   // 若是没有该key值
          array .push(arr[i]);
        }
      }
      return array ;
    }

十、利用reduce+includes 去重it

var arr = [1, 1, 'true', 'true', true, true, 15, 15, false, false, null, null, NaN, NaN, 'NaN', 0, 0, 'a', 'a', { }, { }];

//利用reduce方法 循环遍历数组，prev做为上一次计算的结果传给下一次运算
//在每次计算中，利用数组的includes方法，判断当前prev中是否含有cur，若是有，则返回当前prev；不然，利用展开运算符合并prev和cur值，最后，返回reduce方法计算的结果

function unique(arr) { 
    return arr.reduce((prev, cur) => { 
        return prev.includes(cur) ? prev : [...prev, cur]
    }, [])  //须要注意的是，当reduce方法有第2个参数时，它为prev的初始值
}

console.log(unique(arr))
//运行结果：
//[1, "true", true, 15, false, null, NaN, "NaN", 0, "a", {}, {}]