js中常见数组去重方法 && 当数组中每项为obj时，数组去重方法

数组去重的方法

当数组中每项为obj时（数据结构为[{}, {}, {}]），去重方法：

let arr = [{ key:1, name: '赵四' }, { key:2, name: '张三' }, { key:1, name: '赵四' }];
let result = [];
let obj = {};
arr.map(item => {
	if (!obj[item.key]) {
		obj[item.key] = item.key;
		result.push(item);
	}
});
console.log(result);
// [{key: 1, name: '赵四'},{key: 2, name: '张三'}]

1、利用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]

2、利用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", {}, {}]

3、利用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", {}, {}]

4、利用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", {}, {}]

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

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", {}, {}]

6、利用includes去重

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", {}, {}]

7、利用hasOwnProperty去重

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', {} ]

8、利用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', {}, {} ]

9、利用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 ;
    }

10、利用reduce+includes 去重

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", {}, {}]