J*aScript 的 Proxy 能否拦截 super 关键字的方法调用？

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

J*aScript 的 Proxy 能否拦截 super 关键字的方法调用？

2025-10-14

浏览次数：次

返回列表

Proxy 无法拦截 super 调用，因为 super 在语言层面直接访问原型链上的方法，不经过对象属性查找机制，因此不会触发 get 或 apply 等 trap 捕获器；例如在类的继承中，super.greet() 直接从 Parent.prototype 查找方法，即使 Child.prototype 的原型被代理，也不会触发 Proxy 的捕获器；虽然无法直接拦截，但可通过代理父类原型间接影响 super 行为，如将 Parent.prototype 替换为 Proxy，在 get 中拦截方法调用并添加额外逻辑；这表明 super 的调用是静态解析且绕过代理机制的，只能通过修改原型链或代理父级原型实现间接控制。

javascript 的 proxy 能否拦截 super 关键字的方法调用？

J*aScript 的 Proxy 无法直接拦截 super 关键字的方法调用。

为什么 Proxy 不能拦截 super 调用？

因为 super 不是通过对象属性查找机制触发的。它在语言层面直接访问原型链上的方法，绕过了 Proxy 的 trap 捕获器（如 get 或 apply）。当使用 super.method() 时，J*aScript 引擎会：

静态确定当前方法所在的类或对象字面量
获取该对象的 [[Prototype]]（即原型）
直接在原型上查找并调用 method

这个过程不涉及对目标对象的属性读取操作，因此不会触发 Proxy 的 get 或 apply 捕获器。

实际例子说明

看一个示例：

const target = {
  greet() {
    return "Hello from target";
  }
};

const handler = {
  get(target, prop, receiver) {
    console.log(`Access to ${prop}`);
    return Reflect.get(...arguments);
  }
};

const proxy = new Proxy(target, handler);

class Parent {
  greet() {
    return "Hello from Parent";
  }
}

class Child extends Parent {
  greet() {
    // 这里 super.greet() 访问的是 Parent.prototype.greet
    // 即使 this.__proto__ 可能被代理，super 仍然直接找 Parent.prototype
    return super.greet() + ", then Child";
  }
}

// 把 Child 实例的原型换成代理
Object.setPrototypeOf(Child.prototype, proxy);

const c = new Child();
console.log(c.greet()); // 输出: "Hello from Parent, then Child"
// 注意：没有触发 Proxy 的 get 捕获器

尽管 Child.prototype 的原型是 proxy，但 super.greet() 并未打印 "Access to greet"，说明 get 没有被触发。

有没有间接方式影响 super 行为？

虽然不能直接拦截 super 调用，但可以通过修改原型链来间接影响：

代理父类原型上的方法本身 —— 如果父类原型是 Proxy，可以捕获对它的调用
重写原型上的方法，在内部做额外逻辑

例如：

const parentProtoProxy = new Proxy(Parent.prototype, {
  get(target, prop, receiver) {
    if (prop === 'greet') {
      return function(...args) {
        console.log('Intercepted super.greet() call');
        return Reflect.get(target, prop, receiver).apply(this, args);
      };
    }
    return Reflect.get(...arguments);
  }
});

// 让 Child 继承自被代理的原型
Object.setPrototypeOf(Child.prototype, parentProtoProxy);