Typescript:如何跳过在多个泛型类上定义类型

Question

我是个打字新手，还在学习。在使用TS时，我遇到了问题:我有一个具有多个泛型属性的类，定义如下

export class MainClass<
    A = string,
    B = number,
    C = boolean> {
    propA: A
    propB: B
    propC: C
}

如果我调用它并定义完整的3种类型，它会工作得很好：

let mainClass = new MainClass<string, string, string>

但是后来我想创建一个新的实例，并且只想定义类型3：

let mainClass2 = new MainClass< , ,custom-type>

我们是否可以省略定义任何泛型(它得到默认类型)而只定义我们需要的泛型？我在谷歌上搜索了几个小时，但没有多少人和我有相同的想法，回答也不是很有帮助，有人能给我指点一下吗？

ThankyoU！

Answer 1

我能想到的唯一方法是创建接受不同类型参数的子类。

我已经在下面演示了您的<,,type>示例。类型注解只是为了展示你(有效地)得到了什么-你不需要在这里添加现实生活中的注解。

class MainClass<A = string, B = number, C = boolean> {
    propA: A
    propB: B
    propC: C
}

class MainClassB<
    C = boolean> extends MainClass<string, number, C> {
}

let example1: MainClass<string, string, string> = new MainClass<string, string, string>();

let example2: MainClass<string, number, number> = new MainClassB<number>();

基本概念是，子类接受您想要的类型参数的任意组合，并返回一个具有MainClass的三个属性的类。如果您想要支持一种或两种不同的默认情况，您可以创建各种组合(消除原始类型参数顺序可以满足的组合)。

完整示例

我在函数中加入了一个接受MainClass的函数，以显示所有结果类型在结构上是兼容的：

class MainClass<A = string, B = number, C = boolean> {
    propA: A
    propB: B
    propC: C
}

class MainClassC<C> extends MainClass<string, number, C> {
}

class MainClassAC<A, C> extends MainClass<A, number, C> {
}

class MainClassBC<B, C = boolean> extends MainClass<string, B, C> {
}

function processMainClass(input: MainClass) {
    console.log(input.propA, input.propB, input.propC);
}

let a = new MainClass<string>();
processMainClass(a);

let b = new MainClassBC<number>();
processMainClass(b);

let c = new MainClassC<boolean>();
processMainClass(c);

let ab = new MainClass<string, number>();
processMainClass(ab);

let ac = new MainClassAC<string, boolean>();
processMainClass(ac);

let bc = new MainClassBC<number, boolean>();
processMainClass(bc);

let abc = new MainClass<string, number, boolean>();
processMainClass(abc);

Answer 2

对于像我这样仍然在这个问题上的人，在这里添加。

export class MainClass<
    A = string,
    B = number,
    C = boolean> {
    propA: A
    propB: B
    propC: C
}

由于您的目标不是创建多个类，因此您可以定义一个类型别名。事情就这么简单

type MainClassWithDefaults<C> = MainClass<"TypeA","TypeB",C>;
let mainClass:MainClassWithDefaults<"TypeYouWantToPass"> = new MainClass()

如果你想要的是one liner，这里就是。这仍然是冗长的，有点误导，并不是在所有情况下都适用，所以我不推荐这样做。如果类中有一个字段属于要跳过的泛型类型(*，而不是联合类型)，则可以这样做。

let mainClass = new MainClass<MainClass["propA"], MainClass["propB"], string>()

*如果字段是联合类型，它将不起作用，原因如下。

假设字段被定义为propA: A | null，MainClass["propA"]返回的类型将不是泛型A的默认类型，而是联合类型A | null。