【数组去重】个人简单记录

数组去重

for 来处理

//方法一:
const arr = [1, 2, 1, 3, 3, 3, 2, 4, 5, 5, 6, 7];
const uniqueArr = []
for (let i = 0; i < arr.length; i++) {
  if (uniqueArr.indexOf(arr[i]) === -1) {
    uniqueArr.push(arr[i])
  }
}
console.log(uniqueArr)

//方法二：
//for of循环 来处理
const arr = [1, 2, 1, 3, 3, 3, 2, 4, 5, 5, 6, 7];
const uniqueArr = []
for (item of arr) {
  if (uniqueArr.indexOf(item) === -1) {
    uniqueArr.push(item)
  }
}
console.log(uniqueArr)

//方法三：
//for 循环嵌套
const arr = [1, 2, 1, 3, 3, 3, 2, 4, 5, 5, 6, 7];
//分别获取数组中的元素
for (let i = 0; i < arr.length; i++) {
//获取当前值后边的所有值
  for (let j = i + 1; j < arr.length; j++) {
  //判断两个数是否相等
    if (arr[i] === arr[j]) {
    //出现了重复元素，删除后边的元素
      arr.splice(j, 1)
/*
		当arr[i]和arr[j]相同时，它会自动的删除j位置的元素，然后j+1位置的元素，会变成j位置的元素
		而j位置己经比较过了，不会重复比较，所以会出现漏比较的情况。
		
		解决办法：当删除一个元素后，需要将该位置的元素在比较一遍
*/
      j--
    }
  }
}
console.log(arr)

//简化写法
const arr = [1, 2, 1, 3, 3, 3, 2, 4, 5, 5, 6, 7];
//获取数组中的元素
for (let i = 0; i < arr.length; i++) {
  const index = arr.indexOf(arr[i], i + 1)
  if (index !== -1) {
    //出现重复内容
    arr.splice(index, 1)
    i--
  }
}
console.log(arr)

flatMap 来处理

//方法一：
const arr = [1, 2, 1, 3, 3, 3, 2, 4, 5, 5, 6, 7];
const uniqueArr = arr.flatMap((item, index) => {
  if (arr.indexOf(item) === index) {
    return [item]; // 返回一个包含单个元素的数组
  } else {
    return []; // 返回一个空数组
  }
});
console.log(uniqueArr);


 //flatMap 方法期望回调函数返回一个数组，
 //如果在回调函数中某些元素不满足条件时没有返回数组
 //而是返回了 undefined，那么这些元素在最终的结果中会变成 undefined。这时候可以结合filter处理
 
 //方法二：
const arr = [1, 2, 1, 3, 3, 3, 2, 4, 5, 5, 6, 7];
const uniqueArr = arr.flatMap((item, index) => {
  if (arr.indexOf(item) === index) {
    return item;
  }
});
const filteredArr = uniqueArr.filter((item) => {
  return item !== undefined && !Array.isArray(item);
});
console.log(filteredArr);

Set 来处理

//方法一：
//Set 和 Array.form 来处理
//使用 Set 创建了一个不包含重复元素的集合， 然后通过 Array.from 将其转换为数组。
const arr = [1, 2, 1, 3, 3, 3, 2, 4, 5, 5, 6, 7];
const uniqueArr = Array.from(new Set(arr))
console.log(uniqueArr)

//方法二：
//   Set 和 拓展运算符 来处理
// 使用 Set 创建了一个不包含重复元素的集合，然后通过 ... 将其转换为数组。
const arr = [1, 2, 1, 3, 3, 3, 2, 4, 5, 5, 6, 7];
const uniqueArr = [...new Set(arr)]
console.log(uniqueArr)

filter 来处理

const arr = [1, 2, 1, 3, 3, 3, 2, 4, 5, 5, 6, 7];
const uniqueArr = arr.filter((item, index) => arr.indexOf(item) === index);
console.log('last---->', uniqueArr);

数组对象去重

const arr = [
  { id: 1, name: "xxxtentacion" },
  { id: 2, name: "amsxtyf" },
  { id: 2, name: "amsxtyf" },
  { id: 1, name: "xxxtentacion" },
  { id: 3, name: "xtyf" }
];

const uniqueArr = arr.filter((item, index) => {
  return (
    index ===arr.findIndex(obj => obj.id === item.id && obj.name === item.name)
  );
});

console.log(uniqueArr);
/* outPut:    [{"id":1,"name":"xxxtentacion"},
			  {"id":2,"name":"amsxtyf"},
			  {"id":3,"name":"xtyf"}]
*/





const arr = [
false,
false,
false,
NaN,
NaN,
NaN,
{ age: 1 },
{ age: 1 },
{ name: 1 },
null,
null,
null,
0,
0,
5,
5,
5,
6,
7,
7,
7,
0,
0,
undefined,
undefined,
undefined,
{},
{},
{},
'NaN',
'NaN',
'NaN',
true,
true,
true
];

function unique(arr) {
var obj = {};
return arr.filter(function (item, index, arr) {
let key;
if (item === null) {
key = 'null';
} else if (item === undefined) {
key = 'undefined';
} else {
key = typeof item === 'object' ? JSON.stringify(Object.keys(item)) : item;
}
return obj.hasOwnProperty(key) ? false : (obj[key] = true);
});
}

console.log(unique(arr));

outPut：