Typescript 为什么在没有指定泛型类型参数的情况下可以实例化泛型类

我不明白为什么TypeScript允许在没有指定实际泛型类型参数的情况下实例化泛型类？ 在下面的示例中，类

Foo

有一个泛型类型参数

T

。 在

const foo=new foo（）

行中，可以创建一个新的

foo

对象，而无需指定泛型类型参数。

foo

具有类型

foo

，

bar

具有类型

valueType

为什么可能，而TypeScript不会引发错误？ 这是什么用例？ TypeScript是否可以强制要求使用泛型类型参数

类型值类型={
名称：string，
密钥：T | null，
};
福班{
私人价值：价值型；
公共构造函数（）{
此值={
名称：“”，
key:null，
};
}
公共设置值（值：valueType）{
这个值=值；
}
public getValue（）：valueType{
返回此.value；
}
}
const foo=新foo（）；
const bar=foo.getValue（）；

我不明白为什么TypeScript允许在没有指定实际泛型类型参数的情况下实例化泛型类

在大多数情况下，可以从参数推断泛型。在这种情况下，没有参数，因此必须显式设置它，否则它将变为

未知

假设我们修改了构造函数，使其以

T

类型的

key

作为参数

public constructor(key: T) {

现在，typescript将自动为实例分配泛型变量，使其成为传递给构造函数的

键

参数的类型。我们不需要编写

newfoo（'x'）

。我们只需编写

newfoo（'x'）

并获得

Foo

TypeScript是否可以强制要求使用泛型类型参数

我不这么认为，但我不确定。它会在你的衣襟里

如果您要求每个泛型函数或类都需要显式声明的泛型，那么很快就会变得非常烦人。类型推断是typescript的基石之一。您只希望在推断为

未知

的情况下需要它

您通常会看到泛型函数和类为泛型设置了一个默认值，在无法推断时使用该值<代码>未知会产生问题，但

任何

都会起作用（只是没有多大帮助）。没有任何东西可以分配给未知的

，但所有东西都可以分配给任何

。您可以将
any
设置为默认值：

class Foo<T = any> {

class-Foo{

现在，当您调用
newfoo（）
时，您将得到
Foo

我不明白为什么TypeScript允许在没有指定实际泛型类型参数的情况下实例化泛型类

在大多数情况下，可以从参数推断泛型。在这种情况下，没有参数，因此必须显式设置泛型，否则泛型将变为
未知

假设我们修改了构造函数，使其以
T
类型的
key
作为参数

public constructor(key: T) {

现在，typescript将自动为我们的实例分配泛型变量，使其成为传递给构造函数的
键
参数的类型。我们不需要编写
new Foo（'x'）
。我们只需编写
new Foo（'x'）
，就可以得到
Foo

TypeScript是否可以强制要求使用泛型类型参数

我不这么认为，但我不确定。这可能是你的衣服里的东西

如果您要求每个泛型函数或类都需要一个显式声明的泛型，那么这将很快变得非常烦人。类型推断是typescript的基石之一。您只希望在推断为
未知的情况下需要它

您通常会看到泛型函数和类为泛型设置默认值，当无法推断时使用。
未知
会产生问题，但
任何
都会起作用（只是没有太大帮助）。没有任何内容可分配给
未知
，但所有内容都可分配给
任何
。您可以将
任何
设置为默认值：

class Foo<T = any> {

class-Foo{

现在，当您调用
newfoo（）时
您得到了
Foo
另一个建议的合理选项是默认为
never
类型。这无疑会导致一个问题，因为
never
类型不能用于任何有意义的事情，所以类的调用方会意识到他们做错了什么，并且他们没有意识到需要将类型参数传递给Foo

type valueType<T> = {
   name: string,
   key: T|null,
};

class Foo<T = never> {
   private value: valueType<T>;

   public constructor() {
      this.value = {
         name: '',
         key: null,
      };
   }

   public setValue(value: valueType<T>) {
      this.value = value;
   }

   public getValue(): valueType<T> {
      return this.value;
   }
}

const foo = new Foo();
// bar will now have the `never` type, making it unusable
const bar = foo.getValue();

类型值类型={
名称：string，
密钥：T | null，
};
福班{
私人价值：价值型；
公共构造函数（）{
此值={
名称：“”，
key:null，
};
}
公共设置值（值：valueType）{
这个值=值；
}
public getValue（）：valueType{
返回此.value；
}
}
const foo=新foo（）；
//bar现在将具有'never'类型，使其无法使用
const bar=foo.getValue（）；
在other中推荐的一个合理选项是默认为
从不
类型。这无疑会导致一个问题，因为
从不
类型不能用于任何有意义的事情，所以类的调用方会意识到他们做错了什么，需要传递类型参数t奥福

type valueType<T> = {
   name: string,
   key: T|null,
};

class Foo<T = never> {
   private value: valueType<T>;

   public constructor() {
      this.value = {
         name: '',
         key: null,
      };
   }

   public setValue(value: valueType<T>) {
      this.value = value;
   }

   public getValue(): valueType<T> {
      return this.value;
   }
}

const foo = new Foo();
// bar will now have the `never` type, making it unusable
const bar = foo.getValue();

类型值类型={
名称：string，
密钥：T | null，
};
福班{
私人价值：价值型；
公共构造函数（）{
此值={
名称：“”，
key:null，
};
}
公共设置值（值：valueType）{
这个值=值；
}
public getValue（）：valueType{
返回此.value；
}
}
const foo=新Fo