<think>我们被要求提供JavaScript对象数组根据某个key去重的方法。根据引用内容，我们有几种不同的方法可以实现这个目标。下面我将总结并展示几种常见的方法，并解释其原理。###方法1：利用对象key的唯一性（推荐）
原理：利用JavaScript对象的键（key）不可重复的特性，将数组元素中要去重的属性值作为对象的键。如果该键已存在，则覆盖（或者跳过），最后将对象的值转换为数组。
```javascriptfunction uniqueByKey(arr,key){constobj ={};arr.forEach(item =>{obj[item[key]]= item; //如果重复，后面的会覆盖前面的});returnObject.values(obj);}```
使用示例：```javascriptconstlist =[{id:1,name:'1'},{id:1,name:'1-1'}, //重复id，这个会覆盖上一个{id:2,name:'2'},{id:3,name:'3'},
];console.log(uniqueByKey(list, 'id'));//输出:[ {id:1,name:'1-1'},{id:2,name:'2'},{id:3,name:'3'} ]```
注意：这种方法会保留最后一个出现的重复项（因为后面的覆盖前面的）。如果希望保留第一个出现的，可以稍作修改：
```javascriptfunction uniqueByKeyKeepFirst(arr, key) {constobj ={};arr.forEach(item =>{//如果还没有这个key，才添加if(!obj[item[key]]) {obj[item[key]]= item;}});return Object.values(obj);
}```
###方法2：使用Array.reduce（保留第一个出现的重复项）
原理：使用reduce方法遍历数组，初始值设为空数组。在遍历过程中，检查当前元素的key是否已经存在于结果数组中，如果不存在则加入。
```javascriptfunction uniqueByKeyWithReduce(arr, key) {returnarr.reduce((res, item) =>{//检查结果数组中是否已经有相同key值的元素if(!res.some(sItem=> sItem[key] ===item[key])) {res.push(item);}return res;}, []);
}```
使用示例同上。注意：这种方法会保留第一个出现的重复项。###方法3：使用Array.filter（保留第一个出现的重复项）原理：使用filter方法，通过索引判断当前元素是否是第一次出现（即当前元素的key在数组中第一次出现的索引等于当前索引）。
```javascriptfunction uniqueByKeyWithFilter(arr,key){return arr.filter((item,index,self)=> {//当前元素在数组中第一次出现的索引等于当前索引，则保留returnself.findIndex(sItem=> sItem[key] ===item[key]) ===index;});}
```###方法4：使用Map（推荐，保留最后一个出现的重复项）原理：利用Map数据结构，将key值作为Map的键，整个对象作为值。由于Map会保留最后一次设置的值，所以最后返回Map的值即可。
```javascriptfunction uniqueByKeyWithMap(arr,key){const map= newMap();arr.forEach(item=> {map.set(item[key],item);});returnArray.from(map.values());
}```
###总结-以上方法各有特点，主要区别在于保留第一个还是最后一个重复项。-方法1（对象）和方法4（Map）性能较好，因为对象和Map的键查找是O(1)的时间复杂度。-方法2（reduce）和方法3（filter）在结果数组中查找元素，时间复杂度为O(n²)，在数据量大时性能较差。###最佳实践如果对保留顺序没有特别要求，且数据量较大，推荐使用方法4（Map）或方法1（对象）：
```javascript//保留最后一个重复项（推荐）function uniqueByKey(arr,key){const map= newMap();arr.forEach(item=> map.set(item[key],item));returnArray.from(map.values());
}//保留第一个重复项functionuniqueByKeyKeepFirst(arr, key) {constmap =new Map();arr.forEach(item =>{if (!map.has(item[key])) {map.set(item[key],item);}});returnArray.from(map.values());
}```
###相关问题1.如何根据多个字段进行去重？2.在去重过程中如何自定义重复的判断条件？
3.如何对去重后的数组进行排序？4.在React/Vue中如何高效地实现数组去重并更新视图？</think>### JavaScript 对象数组根据指定 Key 去重的 4 种方法
#### ✅ 方法 1：利用对象键值唯一性（高效推荐）
```javascript
function deduplicateByKey(arr, key) {
const obj = {};
arr.forEach(item => {
obj[item[key]] = item; // 相同key会覆盖，保留最后出现的项
});
return Object.values(obj);
}
// 使用示例
const users = [
{id: 1, name: '张三'},
{id: 2, name: '李四'},
{id: 1, name: '张三新版'}, // 重复id
{id: 3, name: '王五'}
];
console.log(deduplicateByKey(users, 'id'));
// 输出: [{id:1, name:'张三新版'}, {id:2, name:'李四'}, {id:3, name:'王五'}]
```
**特点**：
- 时间复杂度 O(n)，性能最佳
- 保留最后一个出现的重复项
- 直接利用 JavaScript 对象键值唯一性[^1][^2]
#### ✅ 方法 2：使用 Array.reduce()（保留首次出现）
```javascript
function deduplicateByKey(arr, key) {
return arr.reduce((acc, current) => {
const exists = acc.some(item => item[key] === current[key]);
return exists ? acc : [...acc, current];
}, []);
}
// 使用示例
console.log(deduplicateByKey(users, 'id'));
// 输出: [{id:1, name:'张三'}, {id:2, name:'李四'}, {id:3, name:'王五'}]
```
**特点**：
- 保留首次出现的重复项
- 函数式编程风格
- 使用展开语法创建新数组[^3]
#### ✅ 方法 3：使用 Map 对象（保留顺序）
```javascript
function deduplicateByKey(arr, key) {
const map = new Map();
arr.forEach(item => {
map.set(item[key], item);
});
return Array.from(map.values());
}
// 使用示例
console.log(deduplicateByKey(users, 'id'));
// 输出: [{id:1, name:'张三新版'}, {id:2, name:'李四'}, {id:3, name:'王五'}]
```
**特点**：
- 保留原始顺序（最后出现的值）
- 更现代的 ES6 语法
- 适合需要保持插入顺序的场景
#### ✅ 方法 4：使用 filter() + findIndex()（保留首次出现）
```javascript
function deduplicateByKey(arr, key) {
return arr.filter(
(item, index, self) =>
index === self.findIndex(i => i[key] === item[key])
);
}
// 使用示例
console.log(deduplicateByKey(users, 'id'));
// 输出: [{id:1, name:'张三'}, {id:2, name:'李四'}, {id:3, name:'王五'}]
```
**特点**：
- 保留首次出现的项
- 单行函数实现
- 时间复杂度 O(n²)，适合小型数组
---
### 方法对比表
| 方法 | 时间复杂度 | 保留项 | 适用场景 |
|------|------------|--------|----------|
| 对象键值 | O(n) | 最后一项 | 大型数组，高性能需求 |
| Array.reduce | O(n²) | 第一项 | 需要首次出现的小型数组 |
| Map 对象 | O(n) | 最后一项 | 需要保持顺序的现代环境 |
| filter+findIndex | O(n²) | 第一项 | 简单场景的小型数组 |
---
### 使用注意事项
1. **大小写敏感**：`item[key]` 比较是大小写敏感的
2. **引用类型值**：当 key 对应的是对象/数组时，需先转为字符串
```javascript
// 处理对象值
obj[JSON.stringify(item[key])] = item;
```
3. **空值处理**：添加空值检查避免错误
```javascript
function deduplicateByKey(arr, key) {
if (!arr || arr.length === 0) return [];
// ...后续逻辑
}
```
---
### 相关问题
1. 如何根据多个字段组合进行对象数组去重？
2. 在去重时如何保留特定条件的重复项（如最新日期）？
3. React/Vue 中如何高效处理大型数组的去重渲染？
4. 如何实现区分大小写的去重操作？
5. 对象数组去重时出现 `[object Object]` 冲突如何解决？
扫一扫
875
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
