Typescript：如何在依赖项中返回正确的类和泛型类型

Question

我正在尝试找到一种方法将一个对象注入另一个对象（依赖注入），其中容器对象可以返回正确注入的对象类型，并且不需要显式地将类型传递给函数（类型推断）。
为确保注入的对象具有通用接口和默认行为，它们将是 Abstract 类的实例。

鉴于我需要在某些地方进行这样的行为，我想避免使用依赖注入框架来做到这一点。

在我看来，我需要在对象实例化时设置泛型类型，因为泛型参数之后无法重新定义。因此，我需要使用 factory（new() 接口）

---

这是一个例子。 Test it in Typescript Playground。为简单起见，我正在寻找 createMyClass2 以返回类型为 ArrayClass<string> 的对象，而无需在调用它时明确指定类型（类型推断）。
比如ArrayClass和ArrayClassAbstract可以认为是在不同的NPM模块中定义的某种插件。

class ArrayClassAbstract<MYTYPE> {
    public arr: Array<MYTYPE> = []
    constructor(element: MYTYPE) {
        this.arr.push(element);
    }
}

class ArrayClass<MYTYPE> extends ArrayClassAbstract<MYTYPE> {
    test() { 
        return this.arr;
    }
}

class SomeOtherArrayClass<MYTYPE> extends ArrayClassAbstract<MYTYPE> {
    test() { 
        return this.arr + "something different";
    }
}

function createMyClass<MYTYPE>
    (className: { new <MYTYPE>(element: MYTYPE): ArrayClassAbstract<MYTYPE> }, element: MYTYPE) { 
    return new className<MYTYPE>(element);
}

let a = createMyClass(ArrayClass, "hop!");   // type: {ArrayClassAbstract<string>}
a.test();                                    // Doesn't work... "test" doesn't exist in ArrayClassAbstract

好的泛型类型，错误的类类型...

function createMyClass2<T extends ArrayClassAbstract<string>>
    (className: { new (element: string): T }, element: string) { 
    return new className(element);
}

let b = createMyClass2(ArrayClass, "hop!");  // type: {ArrayClass<any>}
b.test();                                    // Works but array elements typed as "any"

好的类类型，错误的泛型类型。 我不知道我声明工厂的方式是否有问题，或者我是否是 Typescript 限制的受害者......

有什么想法吗？

Answer 1

您只需要第二个类型参数。还是可以推断的：

// Renamed some stuff for clarity
type ConstructorFor<CtorArg, Inst> = { new(element: CtorArg): Inst; }; 
function createMyClass<CtorArg, InstType extends ArrayClassAbstract<CtorArg>>(ctor: ConstructorFor<CtorArg, InstType>, arg: CtorArg) { 
    return new ctor(arg);
}

let a = createMyClass(ArrayClass, "hop!");   // type: {ArrayClass<string>}
a.test(); // OK

Answer 2

使用重载怎么样？

function createMyClass2<MYTYPE>(type: typeof ArrayClass, element: MYTYPE): ArrayClass<MYTYPE>;
function createMyClass2<MYTYPE>(type: typeof SomeOtherArrayClass, element: MYTYPE): SomeOtherArrayClass<MYTYPE>;
function createMyClass2(className, element) {
    return new className(element);
}

let b = createMyClass2(ArrayClass, "hop!");  // type: {ArrayClass<string>}
b.test();
let c = createMyClass2(ArrayClass, 123);  // type: {ArrayClass<number>}
c.test();
let d = createMyClass2(SomeOtherArrayClass, "hop!");  // type: {SomeOtherArrayClass<string>}
d.test();