一个数组对象，如果存在相同的则去掉
您可以使用以下方法来去掉数组对象中的重复项：
- 使用Set数据结构：将数组转换为Set，然后将其转回数组。
const arr = [1, 2, 3, 2, 4, 1];
const uniqueArr = [...new Set(arr)];
console.log(uniqueArr); // [1, 2, 3, 4]
- 使用filter()方法：使用filter()方法遍历数组，只保留第一次出现的元素。
const arr = [1, 2, 3, 2, 4, 1];
const uniqueArr = arr.filter((item, index) => arr.indexOf(item) === index);
console.log(uniqueArr); // [1, 2, 3, 4]
- 使用reduce()方法：使用reduce()方法遍历数组，将第一次出现的元素添加到结果数组中。
const arr = [1, 2, 3, 2, 4, 1];
const uniqueArr = arr.reduce((acc, cur) => {
if (!acc.includes(cur)) {
acc.push(cur);
}
return acc;
}, []);
console.log(uniqueArr); // [1, 2, 3, 4]
以上三种方法都可以用于去除数组对象中的重复项，您可以根据自己的喜好和需求选择其中一种。
并非去除重复项，而是如果有重复项则保留不重复的
如果您想保留不重复的元素，可以使用以下方法：
- 使用Set数据结构：将数组转换为Set，然后使用filter()方法过滤掉在原始数组中出现过多次的元素。
javascriptCopy code
const arr = [1, 2, 3, 2, 4, 1];
const set = new Set(arr);
const uniqueArr = arr.filter(item => set.has(item) && set.delete(item));
console.log(uniqueArr); // [3, 4]
- 使用reduce()方法：使用reduce()方法遍历数组，将只出现一次的元素添加到结果数组中。
const arr = [1, 2, 3, 2, 4, 1];
const count = arr.reduce((acc, cur) => {
acc[cur] = (acc[cur] || 0) + 1;
return acc;
}, {});
const uniqueArr = arr.reduce((acc, cur) => {
if (count[cur] === 1) {
acc.push(cur);
}
return acc;
}, []);
console.log(uniqueArr); // [3, 4]
以上两种方法都可以用于保留数组对象中不重复的元素，您可以根据自己的喜好和需求选择其中一种。
如果是数组对象呢
如果您想针对数组对象进行去重，则需要对比对象的某个属性来判断它们是否相等。以下是两种常见的方法：
- 使用reduce()方法：使用reduce()方法遍历数组对象，将只出现一次的元素添加到结果数组中。
const arr = [
{ id: 1, name: "apple" },
{ id: 2, name: "banana" },
{ id: 3, name: "apple" },
{ id: 4, name: "orange" },
{ id: 2, name: "banana" },
];
const count = arr.reduce((acc, cur) => {
acc[cur.name] = (acc[cur.name] || 0) + 1;
return acc;
}, {});
const uniqueArr = arr.reduce((acc, cur) => {
if (count[cur.name] === 1) {
acc.push(cur);
}
return acc;
}, []);
console.log(uniqueArr);
/*
[
{ id: 1, name: 'apple' },
{ id: 4, name: 'orange' },
]
*/
- 使用Map数据结构：使用Map数据结构存储数组对象，将对象的某个属性作为键，遍历完成后将Map中的值转为数组。
const arr = [
{ id: 1, name: "apple" },
{ id: 2, name: "banana" },
{ id: 3, name: "apple" },
{ id: 4, name: "orange" },
{ id: 2, name: "banana" },
];
const map = new Map();
arr.forEach(item => map.set(item.name, item));
const uniqueArr = Array.from(map.values());
console.log(uniqueArr);
/*
[
{ id: 1, name: 'apple' },
{ id: 2, name: 'banana' },
{ id: 4, name: 'orange' },
]
*/
以上两种方法都可以用于对数组对象进行去重，您可以根据自己的喜好和需求选择其中一种。
如果id不同那么不是不行吗
是的，如果您的数组对象中有唯一标识符（例如id）并且它们是唯一的，那么您可以使用类似于去重数组的方法来去重数组对象。以下是两种方法：
- 使用reduce()方法：使用reduce()方法遍历数组对象，使用一个临时对象来存储已经出现的id，只将首次出现的元素添加到结果数组中。
const arr = [
{ id: 1, name: "apple" },
{ id: 2, name: "banana" },
{ id: 3, name: "apple" },
{ id: 4, name: "orange" },
{ id: 2, name: "banana" },
];
const uniqueArr = arr.reduce((acc, cur) => {
if (!acc.ids[cur.id]) {
acc.ids[cur.id] = true;
acc.result.push(cur);
}
return acc;
}, { ids: {}, result: [] }).result;
console.log(uniqueArr);
/*
[
{ id: 1, name: 'apple' },
{ id: 2, name: 'banana' },
{ id: 3, name: 'apple' },
{ id: 4, name: 'orange' }
]
*/
- 使用Map数据结构：使用Map数据结构存储数组对象，将对象的id作为键，遍历完成后将Map中的值转为数组。
const arr = [
{ id: 1, name: "apple" },
{ id: 2, name: "banana" },
{ id: 3, name: "apple" },
{ id: 4, name: "orange" },
{ id: 2, name: "banana" },
];
const map = new Map();
arr.forEach(item => map.set(item.id, item));
const uniqueArr = Array.from(map.values());
console.log(uniqueArr);
/*
[
{ id: 1, name: 'apple' },
{ id: 2, name: 'banana' },
{ id: 3, name: 'apple' },
{ id: 4, name: 'orange' }
]
*/
以上两种方法都可以用于对具有唯一标识符的数组对象进行去重，您可以根据自己的需求和喜好选择其中一种。
判断一个数组对象中，完全相同的对象出现的次数
要判断一个数组对象中完全相同的对象出现的次数，您可以使用以下方法：
const arr = [
{ id: 1, name: "apple" },
{ id: 2, name: "banana" },
{ id: 3, name: "apple" },
{ id: 4, name: "orange" },
{ id: 2, name: "banana" },
{ id: 1, name: "apple" }
];
const objCount = {};
arr.forEach((obj) => {
const objStr = JSON.stringify(obj);
objCount[objStr] = objCount[objStr] ? objCount[objStr] + 1 : 1;
});
console.log(objCount);
/*
{
'{"id":1,"name":"apple"}': 2,
'{"id":2,"name":"banana"}': 2,
'{"id":3,"name":"apple"}': 1,
'{"id":4,"name":"orange"}': 1
}
*/
以上代码中，我们使用了一个空对象 objCount 来存储每个对象出现的次数。对于数组中的每个对象，我们将其转换为字符串并将其作为键存储在 objCount 对象中，如果对象已经出现过，则将其对应的值加1，否则将其对应的值设为1。最后 objCount 对象中的每个键值对的值即为相同对象出现的次数。
需要注意的是，这种方法依赖于对象的属性顺序和值，如果对象中的属性顺序不同，或者某些属性的值是对象或函数等无法序列化为字符串的类型，则无法正确地统计相同对象的出现次数。如果您需要比较复杂的对象，可以考虑使用第三方库，如Lodash的 isEqual 方法来进行比较。
