TypeScript 的类型系统是图灵完备的，这意味着你可以在类型层面实现几乎任何计算逻辑。这项能力常被称为"类型体操"（Type Gymnastics）。在实际项目中适度使用高级类型，可以在不增加运行时开销的前提下，极大地提升代码的类型安全性。本文将系统性地梳理 TypeScript 5.x 中高级类型的关键概念，并结合实际开发场景给出可落地的实践建议。

1. 条件类型：类型系统里的 if/else

条件类型是 TypeScript 类型体操的基石。它的语法与 JavaScript 中的三元表达式非常相似：

type IsString<T> = T extends string ? true : false;

type A = IsString<"hello">; // true
type B = IsString<number>;   // false

条件类型的强大之处在于配合泛型使用时，它会在联合类型上自动进行分布式计算：

type ToArray<T> = T extends any ? T[] : never;

// 分布式条件类型：对联合类型的每个成员分别求值，再合并
type Result = ToArray<string | number>;
// string[] | number[]

在实际项目中，条件类型最常见的应用场景是根据输入类型推断输出类型。例如，一个 API 请求函数可以根据请求参数的类型自动推断返回值类型：

interface User { id: number; name: string; }
interface Order { id: number; amount: number; }

type ApiResponse<T> = T extends { type: "user" }
  ? User
  : T extends { type: "order" }
  ? Order
  : never;

function fetchApi<T extends { type: string }>(params: T): Promise<ApiResponse<T>> {
  // 实现细节省略
  return fetch("/api", { body: JSON.stringify(params) }) as any;
}

// 返回值类型自动推断为 Promise<User>
const user = await fetchApi({ type: "user", id: 1 });

2. 模板字面量类型：类型层面的字符串操作

TypeScript 4.1 引入的模板字面量类型在 5.x 版本中已经非常成熟。它允许你在类型层面进行字符串拼接、拆分和模式匹配：

type EventName<T extends string> = `on${Capitalize<T>}`;

type ClickEvent = EventName<"click">;  // "onClick"
type FocusEvent = EventName<"focus">;  // "onFocus"

// 结合条件类型和 infer 进行字符串解析
type ParseRoute<T extends string> =
  T extends `${infer Method} /api/${infer Path}`
    ? { method: Method; path: `/${Path}` }
    : never;

type Route = ParseRoute<"GET /api/users">;
// { method: "GET"; path: "/users" }

在实际开发中，模板字面量类型非常适合用于定义严格的事件名称、路由路径、CSS 类名等字符串常量集合，从而在编译期发现拼写错误。

3. infer 关键字：在类型中提取信息

infer 关键字只能在条件类型的 extends 子句中使用，用于在模式匹配中捕获类型变量：

// 提取 Promise 包装的值类型
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

type T1 = UnwrapPromise<Promise<number>>; // number
type T2 = UnwrapPromise<string>;            // string（非 Promise 原样返回）

// 提取函数返回值类型
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

// 提取数组元素类型
type ElementType<T> = T extends (infer E)[] ? E : never;

infer 可以与模板字面量类型结合，实现更复杂的字符串解析。在实际项目中，这类模式常用于编写类型安全的 API 客户端和路由系统。

4. 递归类型：处理嵌套结构

TypeScript 支持递归类型定义，这对于处理树形数据、嵌套 JSON 等场景非常有用：

// 深层递归地将所有属性变为只读
type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object
    ? T[K] extends Function
      ? T[K]
      : DeepReadonly<T[K]>
    : T[K];
};

interface Config {
  server: { host: string; port: number };
  features: string[];
}

type ReadonlyConfig = DeepReadonly<Config>;
// { readonly server: { readonly host: string; readonly port: number }; readonly features: readonly string[] }

需要注意的是，TypeScript 对递归深度有默认限制（通常是 50 层），在处理极深的数据结构时可能需要通过尾递归优化来规避这个限制。

5. 实战案例：类型安全的 API 客户端

下面是一个综合运用上述概念的实战案例——一个类型安全的 API 客户端封装：

// 定义 API 路由及其请求/响应类型
interface ApiRoutes {
  "/user/info": {
    request: { userId: number };
    response: { name: string; email: string };
  };
  "/user/update": {
    request: { userId: number; name: string };
    response: { success: boolean };
  };
  "/order/list": {
    request: { page: number; size: number };
    response: { items: { id: number; amount: number }[]; total: number };
  };
}

// 类型安全的请求函数
async function apiCall<P extends keyof ApiRoutes>(
  path: P,
  data: ApiRoutes[P]["request"]
): Promise<ApiRoutes[P]["response"]> {
  const response = await fetch(path, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(data),
  });
  return response.json();
}

// 使用时，路径、请求参数和返回值都有完整的类型提示
const user = await apiCall("/user/info", { userId: 123 });
// user.name, user.email 自动补全，类型安全

6. 类型体操的边界与建议

类型是写给同事看的文档，也是编译器留给自己的备忘录。但要记住——类型的目的是降低认知负担，而不是展示技巧。

在实际项目中运用高级类型时，我建议遵循以下原则：

  • 可读性优先——如果一段类型代码需要 5 分钟才能读懂，考虑拆分为多个具名类型辅助理解。
  • 不为类型而类型——不要为了用高级特性而用，只在确实能减少出错概率的场景下引入。
  • 关注编译性能——复杂的递归类型和大型联合类型的分布式计算会显著增加编译时间，在大型项目中要注意控制。
  • 善用工具类型——TypeScript 内置的 Partial、Required、Pick、Omit 等工具类型已经覆盖了大部分日常需求，优先使用它们。

总结

TypeScript 的类型体操是一门值得深入学习的技能。它让你能够在编译期捕获更多错误，减少运行时防御性代码的编写量，同时提供更好的 IDE 自动补全体验。但正如任何强大的工具一样，关键在于适度——用合适的复杂度解决合适的问题，才是最好的工程实践。