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

技术博客 (317) 2024-01-05 09:01:01

数组去重的方法

当数组中每项为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", {}, {}]
THE END

发表回复