TypeScript 泛型约束：extends 与 keyof T

泛型约束限制了类型参数可以是什么。<T extends { length: number }> 只接受带有数值 length 的类型（字符串、数组、你自己的对象），正因为有这个保证，函数才可以读取 .length。

function longest<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}

console.log(longest("apple", "fig"));        // apple
console.log(longest([1, 2, 3], [4]));        // [ 1, 2, 3 ]
console.log(longest({ length: 2, tag: "x" }, { length: 5, tag: "y" })); // { length: 5, tag: 'y' }

// @ts-expect-error: Argument of type 'number' is not assignable to parameter of type '{ length: number; }'.
longest(10, 20);

返回类型仍然是 T，而不是 { length: number }：传入两个数字数组，得到的是 number[]，对象也保留了它们的 tag。约束描述的是最低要求；调用方的类型会被保留下来。

为什么需要约束

在泛型函数内部，没有约束的 T 可以是任何东西：字符串、数字、null、函数。所以 TypeScript 只允许对所有类型都有效的操作，而这几乎什么都没有。

// This does not compile: T could be number or undefined, which have no length.
function longest<T>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}

console.log(longest("apple", "fig"));

编译器输出：

index.ts(3,12): error TS2339: Property 'length' does not exist on type 'T'.
index.ts(3,24): error TS2339: Property 'length' does not exist on type 'T'.

解决办法是说明你需要什么：<T extends { length: number }>。约束把“任何类型”变成了“任何具有这些内容的类型”，而这通常正是泛型函数想表达的意思。

约束为接口

约束可以是任何类型，包括你已有的接口或类型别名。这样函数就能处理至少拥有这些成员的任何东西，同时仍然返回调用方的完整类型。

interface HasId {
  id: number;
}

function byId<T extends HasId>(items: T[], id: number): T | undefined {
  return items.find((item) => item.id === id);
}

function indexById<T extends HasId>(items: T[]): Map<number, T> {
  return new Map(items.map((item) => [item.id, item]));
}

const users = [
  { id: 1, name: "Ada", role: "admin" },
  { id: 2, name: "Grace", role: "editor" },
];

const found = byId(users, 2);
console.log(found?.name);              // Grace (found keeps name and role)
console.log(indexById(users).get(1));  // { id: 1, name: 'Ada', role: 'admin' }

和普通的参数类型对比一下：function byId(items: HasId[], id: number): HasId | undefined 接受同样的数组，但结果只是 HasId，所以 found.name 会报错。泛型版本则把完整的类型传递了出来。

K extends keyof T：安全的属性访问

最常见的约束是把两个类型参数关联起来。K extends keyof T 表示 K 必须是 T 的某个属性名，而 T[K] 就是该属性的类型。

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {
  return items.map((item) => item[key]);
}

const book = { title: "Dune", year: 1965, tags: ["sci-fi"] };

const year = getProperty(book, "year");   // number
const title = getProperty(book, "title"); // string
console.log(year + 1, title.toUpperCase()); // 1966 DUNE

const books = [book, { title: "Emma", year: 1815, tags: [] }];
console.log(pluck(books, "year"));        // [ 1965, 1815 ]

// @ts-expect-error: Argument of type '"author"' is not assignable to parameter of type '"tags" | "title" | "year"'.
getProperty(book, "author");

拼错或不存在的键会产生编译错误，返回类型也跟着键变化："year" 得到 number，"title" 得到 string。keyof 本身的内容，包括它和索引签名一起使用时的表现，见 keyof 页面。

约束为基本类型

约束可以是一个基本类型，也可以是若干基本类型的联合。一个有用的副作用是：当 T extends string（或 number）时，TypeScript 会推断出实参的字面量类型，而不是把它拓宽。

function maxOf<T extends number | bigint>(values: T[]): T {
  return values.reduce((a, b) => (b > a ? b : a)); // < and > work on the constraint
}

function createEvent<T extends string>(name: T): { type: T } {
  return { type: name };
}

console.log(maxOf([3, 9, 4]));           // 9
console.log(maxOf([10n, 2n]));           // 10n

const evt = createEvent("user.saved");   // evt: { type: "user.saved" }
const same: "user.saved" = evt.type;     // the literal survived
console.log(same);                       // user.saved

没有约束时，createEvent("user.saved") 返回 { type: string }：这里 TypeScript 把它为 T 推断出的字面量拓宽成了 string。有了 T extends string，字面量就被保留下来，带类型的事件和路由辅助函数正是这样从普通字符串参数中得到精确名称的。

常见错误

返回只符合约束的值。 返回 T 的函数必须返回一个 T，而不是随便一个符合约束的值：

interface HasId {
  id: number;
}

function reset<T extends HasId>(item: T): T {
  return { id: item.id };
}
// error TS2322: Type '{ id: number; }' is not assignable to type 'T'.
//   '{ id: number; }' is assignable to the constraint of type 'T', but 'T' could be
//   instantiated with a different subtype of constraint 'HasId'.

如果 T 是 { id: number; name: string }，新对象没有 name，所以它不是 T。返回输入的展开 return { ...item, id: 0 };，这样能保留所有属性；或者如果你产生的就只有这些，就把返回类型声明为 HasId。

传入违反约束的类型实参。 显式的类型实参同样会被检查：对于 function scale<T extends number>(x: T)，调用 scale<string>("2") 会失败，报错 Type 'string' does not satisfy the constraint 'number'.（TS2344）。

不需要泛型时也加约束。 如果 T 只出现在参数中，那么 function print<T extends HasId>(item: T): void 就只是多了些语法的 function print(item: HasId): void。只有当 T 还出现在返回类型或另一个参数中时，约束才有意义。

带默认值的约束

类型参数可以同时拥有约束和默认值。默认值必须满足约束。

interface Store<TState extends object = Record<string, unknown>> {
  get(): TState;
  set(next: Partial<TState>): void;
}

type AnyStore = Store;                              // Store<Record<string, unknown>>
type CounterStore = Store<{ count: number }>;       // fine
type BadStore = Store<number>;
// error TS2344: Type 'number' does not satisfy the constraint 'object'.

同样的 extends 关键字也出现在条件类型 T extends string ? A : B 中，在那里它是一个判断而不是限制；这种形式见条件类型页面。