JavaScript无法直接用Proxy代理原型，因原型是只读内部属性且Proxy不拦截隐式原型查找；但可通过代理实例、包装构造函数或代理prototype对象（仅显式访问有效）间接控制，推荐ES6类配合实例级Proxy方案。
JavaScript 中不能直接用 Proxy 代理普通对象的原型（__proto__ 或 prototype），因为原型本身是只读的内部属性，且 Proxy 只能代理具体对象实例，不能“拦截”原型链上的隐式查找过程。但你可以通过包装构造函数、实例或中间代理层，间接实现对原型访问行为的控制。
用 Proxy 包装构造函数，拦截 new 调用后的实例行为
这是最常用且可行的方式：不代理原型对象本身，而是代理由该构造函数创建的实例，使其在访问属性时按需委托给原型，并可插入自定义逻辑（如日志、权限检查、懒加载等）。
示例：
function Person(name) {
this.name = name;
}
Person.prototype.say = function() {
return `Hello, I'm ${this.name}`;
};
// 创建一个代理工厂，返回带行为控制的实例
function createProxiedInstance(ctor, ...args) {
const instance = new ctor(...args);
return new Proxy(instance, {
get(target, prop, receiver) {
// 先查实例自身
if (prop in target) {
return Reflect.get(target, prop, receiver);
}
// 再查原型（显式委托）
const protoValue = Reflect.get(Object.getPrototypeOf(target), prop, receiver);
if (typeof protoValue === 'function') {
return protoValue.bind(target); // 绑定 this
}
return protoValue;
},
set(target, prop, value, receiver) {
return Reflect.set(target, prop, value, receiver);
}
});
}
const p = createProxiedInstance(Person, 'Alice');
console.log(p.say()); // "Hello, I'm Alice"
代理 prototype 对象本身（有限制，仅适用于显式调用）
虽然无法让 p.say() 自动触发代理，但你可以把 Person.prototype 本身设为一个 Proxy。这样当代码**显式访问原型上的方法或属性**（如 Person.prototype.say）时，能拦截；但不会影响实例的隐式原型链查找。
立即学习“Java免费学习笔记（深入）”；
注意：这会改变所有基于该构造函数的实例行为的前提——你必须确保所有访问都走这个代理原型，且不能依赖原生原型链机制。
示例：
const originalProto = Person.prototype;
Person.prototype = new Proxy(originalProto, {
get(target, prop, receiver) {
console.log(`[Proxy] Getting ${String(prop)} from prototype`);
return Reflect.get(target, prop, receiver);
},
set(target, prop, value, receiver) {
console.log(`[Proxy] Setting ${String(prop)} on prototype`);
return Reflect.set(target, prop, value, receiver);
}
});
// 显式访问会触发代理
console.log(Person.prototype.say); // 打印日志 + 返回函数
// 但实例调用仍走原生查找（除非重写 __proto__，不推荐）
const p2 = new Person('Bob');
console.log(p2.say()); // 不触发上面的 Proxy！
用 ES6 类 + 实例级 Proxy 拦截全部访问（推荐现代方案）
结合 class 语法和 Proxy，在构造时统一包装实例，是最清晰、可维护的方式。还能配合 has、apply 等 trap 做更细粒度控制。
- 所有属性/方法访问都经过 Proxy，包括继承自原型的
- 可统一处理
this绑定、异步延迟、缓存、访问审计等 - 不影响原有类定义，兼容性好
示例（增强版）：
class Animal {
constructor(name) { this.name = name; }
}
Animal.prototype.speak = function() {
return `${this.name} makes a sound`;
};
function wrapWithProxy(instance) {
return new Proxy(instance, {
get(target, prop) {
const value = Reflect.get(target, prop);
if (value !== undefined) return value;
// 委托到原型（支持多层继承）
const proto = Object.getPrototypeOf(target);
if (proto && proto !== Object.prototype) {
const protoVal = proto[prop];
if (typeof protoVal === 'function') {
return protoVal.bind(target);
}
return protoVal;
}
return undefined;
},
has(target, prop) {
return prop in target || prop in Object.getPrototypeOf(target);
}
});
}
const dog = wrapWithProxy(new Animal('Dog'));
console.log(dog.speak()); // "Dog makes a sound"
不推荐的做法：修改 __proto__ 指向代理对象
有人尝试将实例的 __proto__ 指向一个 Proxy，试图拦截原型访问。但这是危险且不可靠的：
- 现代 JS 引擎（V8）对
__proto__的设置有严格限制，可能静默失败或抛错 - Proxy 代理的对象若作为原型，其
gettrap 在原型链查找中不会被调用（规范明确要求忽略） - 破坏对象一致性，调试困难，与
instanceof、Object.getPrototypeOf等行为冲突
简言之：不能靠改 __proto__ 让原型链访问走 Proxy。
