使用 class 装饰器来改变子类方法

Question

如何使用 class 装饰器来更改装饰类的子类的方法？ 这是一个改变类自己方法的例子，但它不适用于子类自己的方法：

export function guardAllNonConstructorOwnMethodsAgainstBadArguments(
  constructor: Function
) {
  const badArguments = new Set(['', undefined, null]);
  const prototype = constructor.prototype;
  Object.getOwnPropertyNames(prototype)
    .filter(
      ownPropertyName =>
        typeof prototype[ownPropertyName] === 'function' &&
        ownPropertyName !== 'constructor'
    )
    .forEach(propertyName => {
      const nonConstructorOwnMethod = prototype[propertyName];
      prototype[propertyName] = function(...args: any[]) {
        const everyArgumentIsGood = args.every(arg => !badArguments.has(arg));
        if (everyArgumentIsGood) {
          return nonConstructorOwnMethod.bind(this)(...args);
        }
      };
    });
}

即，对于这个例子，我怎样才能修改这个装饰器，以便应用这个装饰器的 class 的子类的方法也可以防止“坏参数”？

Answer 1

Class 装饰器在 class 定义时被调用一次。 它们不作用于子类。 如果你想装饰子类，你可能应该装饰每个子类。

否则，据我所知，当子类恰好扩展了已经装饰的超类时，您无法设置全局挂钩来触发代码运行。 我能想到的最接近的做法是让子类在创建第一个实例时调用您的代码。 也就是说， class Subclass extends Superclass {}不会触发任何东西，但是new Subclass()会触发代码，而下一个new Subclass()不会。 它可能对你来说已经足够好了。 这是我可以想象的一种方式：

const callForThisClassAndForEachSubclass =
    (cb: ((ctor: new (...args: any) => void) => void)) =>
        (ctor: new (...args: any) => any) => {
            const registry = new Set<new (...args: any) => any>();
            const alreadyDecorated = Symbol();
            const {[ctor.name]: newCtor} = {
                [ctor.name]: class extends ctor {
                    constructor(...args: any) {
                        super(...args);
                        const thisCtor = this.constructor as new (...args: any) => any;
                        if (!registry.has(thisCtor)) {
                            cb(thisCtor);
                            registry.add(thisCtor);
                        }
                    }
                }
            };
            cb(newCtor);
            registry.add(newCtor);
            return newCtor;
        };

这将创建一个构造函数注册表，并为它看到的每个构造函数只调用一次回调。 我们必须重写超类的构造函数才能在构造子类时发生这种情况。 看起来很复杂，但让我们看看它的实际效果：

const log = (ctor: new (...args: any) => any) => {
    console.log("I'm decorating this", ctor);
}

console.log("before superclass declaration")  
@callForThisClassAndForEachSubclass(log)
class Superclass {

} // I'm decorating this function Superclass()
new Superclass(); // nothing

console.log("before subclass declaration")
class Subclass extends Superclass {
} // nothing

console.log("before subclass instance")
new Subclass(); // I'm decorating this function Subclass()
console.log("before subclass instance")
new Subclass(); // nothing

console.log("before subclass2 declaration")
class Subclass2 extends Superclass {
} // nothing

console.log("before subclass2 instance")
new Subclass2(); // I'm decorating this function Subclass2()
console.log("before subclass2 instance")
new Subclass2(); // nothing

console.log("before subsubclass declaration")
class SubSubclass extends Subclass {
} // nothing

console.log("before subsubclass instance")
new SubSubclass(); // I'm decorating this function SubSubclass2()
console.log("before subsubclass instance")
new SubSubclass(); // nothing

您可以看到 function log()在 class 创建时为SuperClass调用一次，并在创建第一个实例时为每个子类调用一次。 如果您使用guardAllNonConstructorOwnMethodsAgainstBadArguments function 而不是log ，它可能对您有用（特别是因为这似乎只涉及方法）但我不能确定，因为问题不包括预期的用例。

无论如何，即使它不起作用，它也可以帮助您考虑基于覆盖超类构造函数以在调用子类构造函数时执行自定义操作的替代解决方案。 祝你好运！

链接到代码