Question

我尝试定义类型安全的mixin()装饰函数，如下所示，

type Constructor<T> = new(...args: any[]) => T;

function mixin<T>(MixIn: Constructor<T>) {
    return function decorator<U>(Base: Constructor<U>) : Constructor<T & U> {
        Object.getOwnPropertyNames(MixIn.prototype).forEach(name => {
            Base.prototype[name] = MixIn.prototype[name];
        });

        return Base as Constructor<T & U>;
    }
}

并按如下方式使用，

class MixInClass {
    mixinMethod() {console.log('mixin method is called')}
}

/**
 *  apply mixin(MixInClass) implicitly (use decorator syntax)
 */
@mixin(MixInClass)
class Base1 {
    baseMethod1() { }
}
const m1 = new Base1();
m1.baseMethod1();
m1.mixinMethod(); // error TS2339: Property 'mixinMethod' does not exist on type 'Base1'.

然后，编译器说m1没有成员'mixinMethod'。

生成的代码如下，

//...
var Base1 = /** @class */ (function () {
    function Base1() {
    }
    Base1.prototype.baseMethod1 = function () { };
    Base1 = __decorate([
        mixin(MixInClass)
    ], Base1);
    return Base1;
}());
//...

看起来mixin装饰器已正确应用。

因此，根据我的理解，m1的类型被推断为Base1 & MixIn。但是编译器说这只是Base1。

我使用了tsc 2.6.2并使用--experimentalDecorators标记编译了这些代码。

为什么编译器无法像我预期的那样识别出类型？

基于@jcalz的回答，我按如下方式修改了我的代码，

type Constructor<T> = new(...args: any[]) => T

function mixin<T1, T2>(MixIns:  [Constructor<T1>, Constructor<T2>]): Constructor<T1&T2>;
function mixin(MixIns) {
    class Class{ };

    for (const MixIn of MixIns) {
        Object.getOwnPropertyNames(MixIn.prototype).forEach(name => {
            Class.prototype[name] = MixIn.prototype[name];
        });
    }

    return Class;
}

class MixInClass1 {
    mixinMethod1() {}
}

class MixInClass2 {
    mixinMethod2() {}
}

class Base extends mixin([MixInClass1, MixInClass2]) {
    baseMethod() { }
}

const x = new Base();

x.baseMethod(); // OK
x.mixinMethod1(); // OK
x.mixinMethod2(); // OK
x.mixinMethod3(); // Property 'mixinMethod3' does not exist on type 'Base' (Expected behavior, Type check works correctly)

这非常有效。我想为可变长度的mixin类改进这个mixin函数。

一种解决方案是添加重载函数声明，如下所示，

function mixin<T1>(MixIns: [Constructor<T1>]): Constructor<T1>;
function mixin<T1, T2>(MixIns: [Constructor<T1>, Constructor<T2>]): Constructor<T1&T2>;
function mixin<T1, T2, T3>(MixIns: [Constructor<T1>, Constructor<T2>, Constructor<T3>]): Constructor<T1&T2&T3>;

但这太难看了。有什么好主意吗？在支持variadic-kind之前是不可能的？

Answer 1

装饰器不会以您期望的方式改变装饰类的类型签名。有一个rather lengthy issue in Github讨论了这一点，并且不清楚是否应该如何（或者是否）实施这种突变。现在的主要问题是编译器将Base1理解为未修饰的类，并且没有装饰版本的名称。

从阅读Github问题开始，看起来建议的解决方法（至少现在）是这样的：

class Base1 extends mixin(MixInClass)(
  class {
    baseMethod1() { }
  }) {
}

所以你没有使用装饰器@表示法，而是直接将装饰器函数应用于匿名类（具有与所需Base1相同的实现），然后继承那得到Base1。现在，编译器了解Base1同时具有baseMethod1()和mixinMethod()。

希望您觉得有帮助。祝你好运！

TypeScript中的类型安全的mixin装饰器

1 个答案: