判断对象是否存在相同值，可以直接使用lodash uniq，可以自己实现。例如，使用Object.values和Set去重比较长度，或通过for...in循环记录值。若值为复杂类型，可用JSON.stringify转换后检查。还可用Map、reduce简化操作。递归方法适用于嵌套对象，而WeakMap可处理复杂引用类型。
方法 1：使用 Object.values 和 Set
利用 Object.values 获取对象的所有值，然后通过 Set 去重，比较去重前后的长度。
代码实现：
javascript
function hasDuplicateValues(obj) {
const values = Object.values(obj);
const uniqueValues = new Set(values);
return values.length !== uniqueValues.size;
}
// 示例
const obj = { a: 1, b: 2, c: 3, d: 2 };
console.log(hasDuplicateValues(obj)); // 输出 true（因为值 2 重复）方法 2：使用 for...in 循环和对象记录
通过 for...in 循环遍历对象的属性值，并使用一个临时对象记录已经出现过的值。
代码实现：
javascript
function hasDuplicateValues(obj) {
const seenValues = {};
for (const key in obj) {
const value = obj[key];
if (seenValues[value]) {
return true; // 发现重复值
}
seenValues[value] = true;
}
return false; // 没有重复值
}
// 示例
const obj = { a: 1, b: 2, c: 3, d: 2 };
console.log(hasDuplicateValues(obj)); // 输出 true方法 3：使用 Array.prototype.some 和 Array.prototype.filter
通过 Object.values 获取所有值，然后使用 some 和 filter 检查是否有重复值。
代码实现：
javascript
function hasDuplicateValues(obj) {
const values = Object.values(obj);
return values.some((value, index) => values.indexOf(value) !== index);
}
// 示例
const obj = { a: 1, b: 2, c: 3, d: 2 };
console.log(hasDuplicateValues(obj)); // 输出 true方法 4：使用 reduce 和 Set
通过 reduce 遍历对象的值，并使用 Set 检查是否有重复值。
代码实现：
javascript
function hasDuplicateValues(obj) {
const values = Object.values(obj);
const hasDuplicates = values.reduce((acc, value) => {
if (acc.seen.has(value)) {
acc.duplicate = true;
}
acc.seen.add(value);
return acc;
}, { seen: new Set(), duplicate: false });
return hasDuplicates.duplicate;
}
// 示例
const obj = { a: 1, b: 2, c: 3, d: 2 };
console.log(hasDuplicateValues(obj)); // 输出 true方法 5：处理特殊值（如 null 和 undefined）
如果对象的值可能包含 null 或 undefined，需要额外处理，因为这些值无法作为对象的键。
代码实现：
javascript
function hasDuplicateValues(obj) {
const seenValues = new Set();
for (const key in obj) {
const value = obj[key];
if (seenValues.has(value)) {
return true; // 发现重复值
}
seenValues.add(value);
}
return false; // 没有重复值
}
// 示例
const obj = { a: null, b: undefined, c: 1, d: null };
console.log(hasDuplicateValues(obj)); // 输出 true（因为 null 重复）方法 6：处理嵌套对象或复杂值
如果对象的值是嵌套对象或复杂类型（如数组、对象等），可以使用 JSON.stringify 将值转换为字符串进行比较。
代码实现：
javascript
function hasDuplicateValues(obj) {
const seenValues = new Set();
for (const key in obj) {
const value = JSON.stringify(obj[key]); // 将值转换为字符串
if (seenValues.has(value)) {
return true; // 发现重复值
}
seenValues.add(value);
}
return false; // 没有重复值
}
// 示例
const obj = { a: { x: 1 }, b: { x: 1 }, c: [1, 2], d: [1, 2] };
console.log(hasDuplicateValues(obj)); // 输出 true（因为 { x: 1 } 和 [1, 2] 重复）方法 7：使用 Array.prototype.reduce 和对象记录
通过 reduce 遍历对象的值，并使用一个对象记录每个值的出现次数。
代码实现：
javascript
function hasDuplicateValues(obj) {
const valueCounts = Object.values(obj).reduce((acc, value) => {
acc[value] = (acc[value] || 0) + 1;
return acc;
}, {});
return Object.values(valueCounts).some(count => count > 1);
}
// 示例
const obj = { a: 1, b: 2, c: 3, d: 2 };
console.log(hasDuplicateValues(obj)); // 输出 true方法 8：使用 Map 记录值
使用 Map 来记录每个值的出现次数，Map 可以处理任何类型的值（包括 null 和 undefined）。
代码实现：
javascript
function hasDuplicateValues(obj) {
const valueMap = new Map();
for (const key in obj) {
const value = obj[key];
if (valueMap.has(value)) {
return true; // 发现重复值
}
valueMap.set(value, true);
}
return false; // 没有重复值
}
// 示例
const obj = { a: 1, b: 2, c: 3, d: 2 };
console.log(hasDuplicateValues(obj)); // 输出 true方法 9：使用 Array.prototype.every 和 Array.prototype.indexOf
通过 every 和 indexOf 检查是否有重复值。
代码实现：
javascript
function hasDuplicateValues(obj) {
const values = Object.values(obj);
return !values.every((value, index) => values.indexOf(value) === index);
}
// 示例
const obj = { a: 1, b: 2, c: 3, d: 2 };
console.log(hasDuplicateValues(obj)); // 输出 true方法 10：使用 lodash 库
如果你已经在项目中使用了 lodash，可以直接使用 _.values 和 _.uniq 来检查重复值。
代码实现：
javascript
const _ = require('lodash');
function hasDuplicateValues(obj) {
const values = _.values(obj);
return values.length !== _.uniq(values).length;
}
// 示例
const obj = { a: 1, b: 2, c: 3, d: 2 };
console.log(hasDuplicateValues(obj)); // 输出 true方法 11：使用 Object.entries 和 Set
通过 Object.entries 获取键值对，然后提取值并使用 Set 去重。
代码实现：
javascript
function hasDuplicateValues(obj) {
const values = Object.entries(obj).map(([key, value]) => value);
const uniqueValues = new Set(values);
return values.length !== uniqueValues.size;
}
// 示例
const obj = { a: 1, b: 2, c: 3, d: 2 };
console.log(hasDuplicateValues(obj)); // 输出 true方法 12：使用递归处理嵌套对象
如果对象的值是嵌套对象，可以使用递归来检查重复值。
代码实现：
javascript
function hasDuplicateValues(obj, seenValues = new Set()) {
for (const key in obj) {
const value = obj[key];
if (typeof value === 'object' && value !== null) {
if (hasDuplicateValues(value, seenValues)) {
return true;
}
} else if (seenValues.has(value)) {
return true;
} else {
seenValues.add(value);
}
}
return false;
}
// 示例
const obj = { a: 1, b: { c: 2 }, d: { e: 2 } };
console.log(hasDuplicateValues(obj)); // 输出 true（因为值 2 重复）方法 13：使用 WeakMap 处理复杂对象
如果对象的值是复杂类型（如对象、数组等），可以使用 WeakMap 来记录值。
代码实现：
javascript
function hasDuplicateValues(obj) {
const seenValues = new WeakMap();
for (const key in obj) {
const value = obj[key];
if (typeof value === 'object' && value !== null) {
if (seenValues.has(value)) {
return true;
}
seenValues.set(value, true);
}
}
return false;
}
// 示例
const obj = { a: { x: 1 }, b: { x: 1 }, c: { y: 2 } };
console.log(hasDuplicateValues(obj)); // 输出 false（因为对象是引用类型，即使内容相同也不重复）方法 14：使用 JSON.stringify 和 Set
如果对象的值是嵌套对象或复杂类型，可以使用 JSON.stringify 将值转换为字符串，然后使用 Set 检查重复。
代码实现：
javascript
function hasDuplicateValues(obj) {
const seenValues = new Set();
for (const key in obj) {
const value = JSON.stringify(obj[key]);
if (seenValues.has(value)) {
return true;
}
seenValues.add(value);
}
return false;
}
// 示例
const obj = { a: { x: 1 }, b: { x: 1 }, c: [1, 2], d: [1, 2] };
console.log(hasDuplicateValues(obj)); // 输出 true（因为 { x: 1 } 和 [1, 2] 重复）总结
- 如果对象的值是简单类型，推荐使用 方法 1 、方法 2 或 方法 8。
- 如果对象的值是嵌套对象或复杂类型，推荐使用 方法 12 或 方法 14。