如何在JavaScript Set中验证非直接引用的对象值？

JS的Set默认用**严格相等（===）**判断元素是否重复或存在，而对象是引用类型——哪怕两个对象内容完全一样，只要不是同一个引用，===就会返回false，这就是你用mySet1.has({ a: 'b' })得到false的原因。

下面是几种可行的解决方法：

方法一：遍历Set手动比较对象内容 #

直接遍历Set中的每个元素，和目标对象做内容比较。如果是结构简单的对象，可以用浅比较；复杂对象则需要深度比较。

浅比较示例（适合简单对象） #

const mySet1 = new Set([
  1, 5, "some text",
  { a: 1, b: 2 },
  { a: 'b' }
]);

function hasObject(set, target) {
  for (const item of set) {
    // 先判断是否都是对象，再比较键和值
    if (typeof item === 'object' && item !== null && typeof target === 'object' && target !== null) {
      const itemKeys = Object.keys(item);
      const targetKeys = Object.keys(target);
      if (itemKeys.length !== targetKeys.length) continue;
      // 逐个比较键值对
      const isEqual = itemKeys.every(key => item[key] === target[key]);
      if (isEqual) return true;
    } else if (item === target) {
      // 处理非对象类型
      return true;
    }
  }
  return false;
}

console.log(hasObject(mySet1, { a: 'b' })); // true
console.log(hasObject(mySet1, 5)); // true

深度比较示例（适合复杂对象） #

如果对象嵌套了其他对象/数组，可以用递归比较，或者借助现成的工具函数：

// 简易版深度比较函数
function deepEqual(obj1, obj2) {
  if (obj1 === obj2) return true;
  if (typeof obj1 !== 'object' || obj1 === null || typeof obj2 !== 'object' || obj2 === null) {
    return false;
  }
  const keys1 = Object.keys(obj1);
  const keys2 = Object.keys(obj2);
  if (keys1.length !== keys2.length) return false;
  for (const key of keys1) {
    if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
      return false;
    }
  }
  return true;
}

function hasObjectDeep(set, target) {
  for (const item of set) {
    if (deepEqual(item, target)) return true;
  }
  return false;
}

console.log(hasObjectDeep(mySet1, { a: 'b' })); // true

方法二：自定义基于内容的Set类 #

封装一个类，内部用Map存储对象的序列化结果作为键，这样就能通过内容判断是否存在。注意：序列化会有局限性（比如无法处理函数、undefined、键顺序不同的对象），适合结构固定的对象。

class ContentSet {
  constructor() {
    this.map = new Map();
  }

  add(item) {
    const key = typeof item === 'object' && item !== null ? JSON.stringify(item) : item;
    this.map.set(key, item);
  }

  has(item) {
    const key = typeof item === 'object' && item !== null ? JSON.stringify(item) : item;
    return this.map.has(key);
  }

  // 可选：实现其他Set方法
  delete(item) {
    const key = typeof item === 'object' && item !== null ? JSON.stringify(item) : item;
    return this.map.delete(key);
  }

  get size() {
    return this.map.size;
  }
}

// 使用示例
const mySet2 = new ContentSet();
mySet2.add(1);
mySet2.add({ a: 'b' });

console.log(mySet2.has({ a: 'b' })); // true
console.log(mySet2.has(1)); // true

注意事项 #

• 使用JSON.stringify序列化对象时，如果对象的键顺序不同（比如{a:1, b:2}和{b:2, a:1}），序列化结果会不一样，导致判断错误。
• 深度比较函数如果自己实现，要考虑数组、Symbol键、循环引用等边界情况，复杂场景建议用成熟的工具库。

内容的提问来源于stack exchange，提问作者Elise Chant