如何在TypeScript中比较泛型参数与类型引用？

因为TypeScript的泛型会在编译时被擦除，无法像C#那样直接通过typeof(T)获取运行时类型信息。要解决这个问题，我们需要将泛型的实例类型与对应的构造函数类型关联起来，同时兼顾编译时的类型安全和运行时的验证需求。

步骤1：精确定义构造函数类型 #

首先优化PluginType的定义，使其更准确地表示能构造MyBase子类实例的构造函数：

abstract class MyBase {
    public test() {}
}

// 定义为抽象构造函数类型，匹配MyBase及其子类的构造函数
type PluginType = abstract new () => MyBase;

// 框架中的createPlugin方法保持不变
function createPlugin(type: PluginType): MyBase {
    // 内部实现：通过类型断言绕过抽象类不能直接实例化的限制
    return new (type as new () => MyBase)();
}

步骤2：重构TestHelper类，关联泛型实例与构造函数 #

调整TestHelper的泛型参数和构造函数参数，让pluginType直接对应泛型T的构造函数类型，这样编译时就能自动约束类型，同时保留运行时的构造函数引用用于验证：

class TestHelper<T extends MyBase> {
    public constructor(
        private readonly pluginName: string,
        // 将pluginType的类型改为T的构造函数类型，而非宽泛的PluginType
        private readonly pluginType: new () => T
    ) {
        // 运行时验证1：确保传入的构造函数确实继承自MyBase
        if (!MyBase.prototype.isPrototypeOf(this.pluginType.prototype)) {
            throw new Error(`插件${pluginName}不是MyBase的子类`);
        }

        // （可选）如果需要**精确匹配具体类**（而非子类兼容），可通过静态属性验证
        // 前提是所有子类都实现了唯一的静态标记，比如typeId
        // if (this.pluginType.typeId !== expectedTypeId) {
        //     throw new Error(`插件${pluginName}与预期类型不匹配`);
        // }
    }

    public createInstance(): T {
        // 将具体构造函数断言为PluginType，适配createPlugin的参数要求
        return createPlugin(this.pluginType as PluginType) as T;
    }
}

步骤3：使用TestHelper（自动推导泛型） #

调用时不需要显式指定泛型T，TypeScript会自动根据传入的构造函数推导实例类型，避免重复指定子类信息：

// 示例子类
class MyPlugin extends MyBase {
    public customMethod() {}
}

// 自动推导T为MyPlugin
const helper = new TestHelper("MyPlugin", MyPlugin);
const instance = helper.createInstance();
instance.customMethod(); // 类型安全，编译时不会报错

进阶：精确匹配的补充方案 #

如果需要运行时精确验证构造函数与预期类完全一致，可以给MyBase添加静态标记属性，让每个子类实现该属性：

abstract class MyBase {
    public static readonly typeId: string;
    public test() {}
}

class MyPlugin extends MyBase {
    public static readonly typeId = "MyPlugin";
}

class TestHelper<T extends MyBase> {
    public constructor(
        private readonly pluginName: string,
        private readonly pluginType: new () => T
    ) {
        // 运行时精确验证：比较静态typeId
        if (this.pluginType.typeId !== this.pluginType.typeId) {
            // 若需要与外部预期值对比，可将预期typeId作为参数传入
            throw new Error(`插件${pluginName}与预期类型不匹配`);
        }
    }

    // ... 其他方法不变
}

这种方案既保证了编译时的类型安全，又实现了运行时的验证，同时避免了重复指定子类信息。

内容的提问来源于stack exchange，提问作者F-H