javascript中proxy数组去重需在创建时预留标识，因运行时无法反射获取target/handler；推荐工厂函数配合weakmap记录元信息，再按target+handler引用去重。
JavaScript 中处理包含代理对象（Proxy）的复杂数组去重，核心难点在于：Proxy 对象默认不可被直接比较或序列化，且没有内置的相等性语义。数组去重依赖“值是否相等”，而 Proxy 实例即使代理同一目标、使用相同 handler，用 === 或 Object.is() 也一定返回 false；用 JSON.stringify() 会失败（抛错或返回 "{}"）。
明确代理对象的“相等”定义
去重前必须先约定：什么情况下两个 Proxy 被视为“重复”？常见合理策略有：
-
按其代理的目标对象（target）和 handler 标识判断：若两个 Proxy 的
target是同一引用，且handler是同一对象（或可安全比对），则视为等价； - 按目标对象内容 + handler 行为逻辑间接判断：例如只关心 target 的结构化数据，忽略 handler 差异（需确保 handler 不改变关键读取行为）；
- 自定义 Symbol.toPrimitive 或 valueOf（不推荐）：Proxy 可拦截这些方法，但仅影响隐式转换，无法支撑通用去重逻辑。
基于 target 引用 + handler 引用的轻量去重
适用于 handler 是固定对象（非动态生成）、且你信任 target 引用唯一性的情况。这是最高效、最可控的方式：
function uniqueProxies(arr) {
const seen = new WeakMap(); // key: target, value: Set of handler refs
const result = [];
for (const item of arr) {
if (item instanceof Proxy) {
const target = item[Symbol.for('proxy-target')]; // ❌ 不行 —— target 不可直接访问
// ✅ 正确方式：用 Reflect.getPrototypeOf(item) 无效，需在创建时保留元信息
}
}
}
⚠️ 注意：Proxy 的 target 和 handler 在运行时不可反射获取（ECMAScript 规范明确禁止）。因此，**可靠做法是在创建 Proxy 时主动记录标识**：
- 创建 Proxy 时，给它加一个不可枚举、不可配置的私有属性（如
$$proxyId），值为唯一符号或对象键； - 或统一用工厂函数创建，内部维护
WeakMap<proxy handler></proxy>映射； - 示例（推荐工厂模式）：
const proxyRegistry = new WeakMap();
function createProxy(target, handler) {
const p = new Proxy(target, handler);
proxyRegistry.set(p, { target, handler });
return p;
}
function isProxyEqual(a, b) {
if (!(a instanceof Proxy) || !(b instanceof Proxy)) return a === b;
const metaA = proxyRegistry.get(a);
const metaB = proxyRegistry.get(b);
if (!metaA || !metaB) return false;
return metaA.target === metaB.target && metaA.handler === metaB.handler;
}
function uniqueByProxyIdentity(arr) {
const seen = new Set();
const result = [];
for (const item of arr) {
const key = item instanceof Proxy
? proxyRegistry.get(item)
: item;
// 用 target + handler 组合作为唯一键（需确保 handler 是同一引用）
const identity = key && 'target' in key
? `${key.target}@@${key.handler}`
: item;
if (!seen.has(identity)) {
seen.add(identity);
result.push(item);
}
}
return result;
}
按 target 内容深度比较（谨慎使用）
若 Proxy 的 handler 未拦截关键属性访问（如 get 基本透传），且 target 是纯数据对象/数组，可对 target 做深比较去重：
- 先用
Array.from(arr, x => x instanceof Proxy ? x._target || Reflect.get(x, '_target') : x)—— 但_target是非法假设； - ✅ 真实可行路径：在创建 Proxy 时，把 target 挂到一个可访问字段（如
p.$$target），并设为不可枚举； - 再配合成熟深比较库（如
fast-deep-equal）或手写简易 deepEqual（限于简单结构）； - 示例：
function createDataProxy(target, handler = {}) {
const p = new Proxy(target, handler);
Object.defineProperty(p, '$$target', {
value: target,
enumerable: false,
configurable: false
});
return p;
}
// 使用 Lodash 的 _.isEqual 或 fast-deep-equal
import equal from 'fast-deep-equal';
function uniqueByTargetContent(arr) {
const seenTargets = [];
return arr.filter(item => {
if (item instanceof Proxy && item.$$target !== undefined) {
if (seenTargets.some(t => equal(t, item.$$target))) {
return false;
}
seenTargets.push(item.$$target);
return true;
}
// 非 Proxy 项走常规去重
if (seenTargets.includes(item)) return false;
seenTargets.push(item);
return true;
});
}
避免陷阱：别踩的坑
以下做法看似方便，实则危险或无效：
-
JSON.stringify(item)：Proxy 会抛TypeError，除非 handler 显式实现toJSON； -
item.toString()或item + ''：触发toString/valueOf拦截，结果不可控且不反映结构； - 用
Map或Set直接存 Proxy：它们用 SameValueZero 比较，Proxy 实例永远不等； - 依赖
Object.keys(item).length或Object.getOwnPropertyNames()：Proxy 可拦截这些，返回结果不代表真实结构。
不复杂但容易忽略：Proxy 去重不是语法问题，而是设计问题——关键在创建阶段就预留可识别的唯一标识或可比依据。临时补救往往成本更高。
Java免费学习笔记：立即使用
解锁 Java 大师之旅：从入门到精通的终极指南
