Question

我有一个像这样的简单班级：

module.exports = class MyClass {

    function middleware() {
        console.log('call me before')
    }

    function a() {

    }
    function b() {

    }

    function c() {

    }
}

所以想法是，当有人调用函数a，b，c时，我想在执行a，b，c之前调用中间件。我该怎么办？

因此，我可以将Middleware（）放到每个函数中，但是我想要一些动态的方法来做到这一点。

Answer 1

您可以使用 Proxy 来捕获实例上的每个属性访问，并包装函数。

class MyClass {
  constructor() {
    const handler = {
      get: function (obj, prop) {
        return typeof obj[prop] !== "function"
          ? obj[prop]
          : function (...args) {
              obj.middleware(prop);
              obj[prop].apply(obj, args);
            };
      },
    };
    return new Proxy(this, handler);
  }

  middleware(prop) {
    console.log(`Executing function ${prop}`);
  }

  a() {}

  b() {}

  c() {}
}

const obj = new MyClass();

obj.a();
obj.b();
obj.c();

Answer 2

您可以通过遍历所有自己的属性名（Object.keys或for..in因为无法枚举类方法而在这里不起作用）来重写类原型的所有方法，然后用替换原始方法一个新方法，该方法不仅调用原始方法，而且还调用中间件。通过这种方式，类的行为不会改变，但是会调用中间件。

 class MyClass {
    a() { console.log("a"); }
 }

 function middleware() { 
    console.log("works");
 }

 for(const key of Object.getOwnPropertyNames(MyClass.prototype)) {
     const old = MyClass.prototype[key];
     MyClass.prototype[key] = function(...args) {
       middleware(...args);
       old.call(this, ...args);
     };
 }

 (new MyClass).a();

Answer 3

您可以做什么，而不是直接调用函数a，b，c，您可以调用中间件并在参数中传递该函数，中间件最后将调用它。

function middleware(targetFunction) {
    console.log('call me before');
    targetFunction();
}

每次使用JS调用类中的任何函数时都要运行一个函数

3 个答案: