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", {}, {}]
THE END
上一篇
