TypeScript泛型接口与泛型函数的类型参数推断差异问题

这个行为差异的核心原因是TypeScript对泛型参数的推断有明确的触发场景边界，泛型类型（接口/类型别名/类）和泛型函数的推断触发时机完全不同。

问题场景复现 #

首先定义泛型接口：

interface Sortable<T> {
  arr: T[];
  sort: (arr: T[]) => T[];
}

直接给变量标注Sortable类型但不传类型参数会直接报错：

// 报错：Generic type 'Sortable<T>' requires 1 type argument(s).
const sortableEmpty: Sortable = {
  arr: [],
  sort: (arr) => arr,
};

必须显式传入泛型参数才能通过类型校验：

const sortableNumbers: Sortable<number> = {
  arr: [2, 0, 1],
  sort: (numbers) =>
    numbers.sort((a, b) => {
      if (a > b) return 1;
      if (a < b) return -1;
      return 0;
    }),
};

interface Person {
  name: string;
  age: number;
}

const sortablePeople: Sortable<Person> = {
  arr: [
    { name: "Charlie", age: 32 },
    { name: "Bob", age: 32 },
    { name: "Alice", age: 8 },
  ],
  sort: (people) =>
    people.sort((a, b) => {
      if (a.age > b.age) return 1;
      if (a.age < b.age) return -1;
      return a.name.localeCompare(b.name);
    }),
};

而泛型函数不需要显式传类型参数，调用时会自动推断：

const applySort = <T>(arr: T[], sort: (arr: T[]) => T[]) => sort(arr);

// 自动推导T为number，无需显式传入
applySort(sortableNumbers.arr, sortableNumbers.sort);
// 自动校验类型不匹配：Type 'Person' is not assignable to type 'number'.
applySort(sortablePeople.arr, sortableNumbers.sort);

甚至当把Sortable<T>作为泛型函数的参数时，TS也能正确推断T的类型：

const identity = <T>(sortable: Sortable<T>) => sortable;

// 自动校验类型不匹配：Type 'number' is not assignable to type 'string'.
identity({
  arr: [2, 0, 1],
  sort: (arr: string[]) => arr,
});

// 自动推导T为number，正常通过
identity({
  arr: [2, 0, 1],
  sort: (arr: number[]) => arr,
});

根本原因 #

1. 泛型类型本身是「类型构造器」，不是具体类型 #

Sortable、Array这种带泛型的类型，本质是接收类型参数、返回具体类型的类型层面函数。你必须传入明确的类型参数，才能得到一个可以用来做变量标注的具体类型——就像你不能调用一个要求传参的普通函数却不给参数一样。

2. 类型标注的语义是「显式约束」，不是「推断触发点」 #

当你写const x: XXX = value时，:后面的类型标注的作用是你主动告诉TS：「x必须符合XXX类型，请帮我校验value是否匹配」。这个位置TS不会做「从value反向推导XXX需要的泛型参数」的操作，否则类型标注就和「完全不写标注、让TS从value自动推导类型」没有区别，会破坏显式类型标注的设计初衷。

3. 观察到的「泛型接口能被推断」，本质是泛型函数的推断能力生效 #

调用identity函数时之所以不需要显式写Sortable<number>，是因为触发推断的主体是泛型函数identity，不是Sortable接口：

• 调用泛型函数时，TS会根据传入的实参，自动推导函数的类型参数T
• 推导得到T的具体类型后，再把参数位置的Sortable<T>实例化为具体类型，最后校验传入的对象是否匹配这个具体类型
  这个过程里Sortable只是被实例化的类型模板，本身没有触发任何推断逻辑。

免显式传参的实现方案 #

如果不想每次创建Sortable实例都显式写泛型参数，可以写一个极简的泛型工厂函数，利用函数调用时的类型推断能力自动推导类型：

const createSortable = <T>(sortable: Sortable<T>) => sortable;

// 自动推导T为number，无需显式传入泛型参数
const autoSortableNumbers = createSortable({
  arr: [2, 0, 1],
  sort: (numbers) => numbers.sort((a, b) => a - b),
});

// 自动推导T为Person
const autoSortablePeople = createSortable({
  arr: [{name: "Alice", age: 8}],
  sort: (people) => people.sort((a,b) => a.age - b.age)
})

这也是TS官方推荐的、用来简化泛型类型实例化的通用方案。

补充：泛型类的行为和泛型接口完全一致，写const arr: Array = [1,2,3]一样会报「需要类型参数」的错误，只有在调用构造函数（本质是泛型函数调用）new Array(1,2,3)时，TS才会自动推导泛型参数为number。

内容的提问来源于stack exchange，提问作者JohannCooper