Proxy无法直接代理原型链，必须递归代理链上每个对象并确保原型关系正确；基础实现需缓存代理、委托get/set到代理后的原型；但存在性能开销、constructor异常、内置对象不适用等问题，多数场景建议采用更轻量方案。
Proxy 本身无法直接代理原型链，因为原型链的查找（如 obj.prop）发生在对象自身及其整个 [[Prototype]] 链上，而 Proxy 只能拦截对代理对象自身的操作。要实现“对原型链的全面代理”，核心思路是：让原型链上的每个对象（包括原型本身）也都被 Proxy 包裹，并确保原型关系在代理后依然正确可访问。
关键原则：代理整个原型链，而非仅目标对象
直接对一个对象使用 new Proxy(obj, handler) 只会拦截对该对象自身的读写，不会影响其 __proto__ 或 Object.getPrototypeOf(obj) 返回的原型对象的行为。若原型上的属性被访问（例如继承的方法被调用），这些操作不会经过当前 Proxy 的 handler。
因此，必须递归地为原型链上的每一层对象创建对应的 Proxy，并在 get 拦截中手动委托到原型代理（而不是原始原型），才能实现连贯的拦截逻辑。
基础实现：递归代理原型链
以下是一个简化但可行的模式，用于创建一个“全链代理”：
立即学习“Java免费学习笔记（深入）”；
function createChainProxy(target, handler = {}) {
// 缓存已代理的对象，避免循环代理
const proxyCache = new WeakMap();
function makeProxy(obj) {
if (!obj || typeof obj !== 'object') return obj;
if (proxyCache.has(obj)) return proxyCache.get(obj);
const proto = Object.getPrototypeOf(obj);
const protoProxy = proto === null ? null : makeProxy(proto);
const proxy = new Proxy(obj, {
get(target, prop, receiver) {
// 优先从自身获取（触发 ownKeys/has 等）
if (prop in target) {
return Reflect.get(target, prop, receiver);
}
// 否则委托给代理后的原型（不是原始 proto！）
if (protoProxy != null) {
return Reflect.get(protoProxy, prop, receiver);
}
return undefined;
},
set(target, prop, value, receiver) {
// 可选择：只允许设置自有属性，或也支持原型赋值（需谨慎）
if (Object.prototype.hasOwnProperty.call(target, prop)) {
return Reflect.set(target, prop, value, receiver);
}
// 若想支持“向原型链写入”，需额外逻辑（通常不推荐）
return false;
},
has(target, prop) {
return Reflect.has(target, prop) || (protoProxy && Reflect.has(protoProxy, prop));
},
ownKeys(target) {
return [...Reflect.ownKeys(target), ...Reflect.ownKeys(protoProxy || {})];
},
getOwnPropertyDescriptor(target, prop) {
const desc = Reflect.getOwnPropertyDescriptor(target, prop);
if (desc) return desc;
return protoProxy ? Reflect.getOwnPropertyDescriptor(protoProxy, prop) : undefined;
}
});
proxyCache.set(obj, proxy);
return proxy;
}
return makeProxy(target);
}
注意事项与限制
-
不能改变原型链结构：Proxy 无法拦截
Object.setPrototypeOf()或__proto__赋值本身；若运行时修改原型，需额外监听或重新代理。 -
constructor 和 instanceof 可能异常：代理对象的
constructor默认指向Object，需在get中特殊处理；instanceof依赖Symbol.hasInstance，需在 handler 中定义。 -
性能开销明显：每级原型都套一层 Proxy，且
get中递归委托，深度链路下会有可观成本。 -
内置对象和宿主对象不适用：如
Array.prototype、Date实例等，其内部行为无法被 Proxy 完全覆盖，部分方法（如Array.prototype.map）可能绕过拦截。
更实用的替代方案
多数场景下，“全面代理原型链”属于过度设计。建议按需选择更稳健的方式：
- 仅代理实例，原型保持干净：把逻辑封装在实例 Proxy 中，原型只放纯函数，避免在原型上依赖可拦截状态。
- 用类 + getter/setter 模拟：在基类中统一定义访问器，由子类继承并重写行为，比 Proxy 更可控。
- 结合 Reflect 和 defineProperty 动态控制：对关键属性显式定义访问器，比全链 Proxy 更轻量、更易调试。
