分享6个对象数组去重的方法

大家好，关于对象数组去重的业务场景，想必大家都遇到过类似的需求吧，针对这样的需求，你是怎么做的呢。

下面我就先和大家讨论下基于对象的某个属性如何去重。

方法一：使用 .filter() 和 .findIndex() 相结合的方法

使用 filter() 方法过滤掉重复的元素，使用 findIndex() 方法判断对象是否重复，代码如下：

1. const arr = [{id: 1, name: "a"}, {id: 2, name: "b"},
2.              {id: 1, name: "c"}, {id: 3, name: "d"}];
3. const uniqueArr = arr.filter((item, index) =>
4.      arr.findIndex(i => i.id === item.id) === index);

方法二：使用 .reduce() 方法

使用 reduce() 方法维护一个累加器，通过对象的属性来判断是否重复，代码如下：

1. const arr = [{id: 1, name: "a"}, {id: 2, name: "b"},
2.              {id: 1, name: "c"}, {id: 3, name: "d"}];
3. const uniqueArr = arr.reduce((acc, curr) => {
4.   if (!acc.find(item => item.id === curr.id)) {
5.     acc.push(curr);
6.   }
7.   return acc;
8. }, []);

方法三：使用 .forEach() 和 .some() 相结合的方法

使用 forEach() 方法遍历数组，使用 some() 方法判断是否重复，代码如下：

1. const arr = [{id: 1, name: "a"}, {id: 2, name: "b"},
2.              {id: 1, name: "c"}, {id: 3, name: "d"}];
3. const uniqueArr = [];
4. arr.forEach(item => {
5.   if (!uniqueArr.some(i => i.id === item.id)) {
6.     uniqueArr.push(item);
7.   }
8. });

方法四：使用 Map

使用 Map 结构去重对象数组时，需要借助 array.map() 函数将对象数组进行转换，示例代码如下：

1. const arr = [{id: 1, name: "a"}, {id: 2, name: "b"},
2.              {id: 1, name: "c"}, {id: 3, name: "d"}];
3. const uniqueArr = [...new Map(arr.map(item => [item.id, item])).values()];

方法五：Object.create()

使用Object.create()，按照对象的属性来判断是否重复，代码如下

1. const arr = [{id: 1, name: "a"}, {id: 2, name: "b"},
2.              {id: 1, name: "c"}, {id: 3, name: "d"}];
3. const uniqueArr = arr.filter(function (item) {
4.     return !this[item.id] && (this[item.id] = true);
5. }, Object.create(null));

方法六：For const of 和 find 结合

这个方法的思想与方法3类似 ，其思路结构如下：

• 创建一个空的唯一数组来存储唯一对象。

• 循环遍历数组中的对象。对于每个对象，如果它不是重复的，则将其添加到唯一数组。否则，忽略它

1. const arr = [{id: 1, name: "a"}, {id: 2, name: "b"},
2.   {id: 1, name: "c"}, {id: 3, name: "d"}];
3. const unique = [];
4. for (const item of arr) {
5.   const isDuplicate = unique.find((obj) => obj.id === item.id);
6.   if (!isDuplicate) {
7.     unique.push(item);
8.   }
9. }

针对多个属性进行去重

有时候，您可能希望仅当对象具有两个或多个具有相同值的属性时才将其视为重复对象——多个属性值相同。

对于这种情况，我们可以将上述方法进行稍微调整就可以进行使用，有部分方法可能不适用,有哪些不合适，这个问题留给大家，欢迎大家在评论区讨论。

我们先使用 .filter() 和 .findIndex() 相结合的方法尝试下，看看如何操作：

1. const arr = [{id: 1, name: "a"}, {id: 2, name: "b"},
2.              {id: 1, name: "a"}, {id: 3, name: "d"}];
3. const uniqueArr = arr.filter((item, index) =>
4.                              arr.findIndex(i => i.id === item.id
5.                                 && i.name === item.name) === index);

我们再使用 For const of 和 find 结合的方法，也能实现同样的效果

1. const arr = [{id: 1, name: "a"}, {id: 2, name: "b"},
2.   {id: 1, name: "a"}, {id: 3, name: "d"}];
3. const unique = [];
4. for (const item of arr) {
5.   const isDuplicate = unique.find((obj) =>
6.     obj.id === item.id && obj.name ==item.name);
7.   if (!isDuplicate) {
8.     unique.push(item);
9.   }
10. }
11. console.log(unique)

结束

其他几个方法的改造，欢迎大家作为练习进行尝试，这里就不再一一举例了，今天的分享就到这里，这些方法都可以实现对象数组的去重，具体使用哪种方法取决于个人的喜好和项目的需求，如果你有其他的方法，欢迎大家在评论区补充，感谢你的关注。