在日常开发中，TypeScript 为我们提供了许多内置的 工具类型（Utility Types），它们本质上是基于泛型和映射类型的封装，能帮助我们快速地从已有类型中派生出新的类型。

Partial<T>

将类型 T 的所有属性变为 可选。

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

type PartialUser = Partial<User>;
// { id?: number; name?: string }

常用场景：定义更新数据的参数（不需要传全量）。

Required<T>

将类型 T 的所有属性变为 必填。

interface User {
  id?: number;
  name?: string;
}

type StrictUser = Required<User>;
// { id: number; name: string }

Readonly<T>

将类型 T 的所有属性变为 只读。

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

type FrozenUser = Readonly<User>;
// { readonly id: number; readonly name: string }

Pick<T, K>

从类型 T 中挑选某些属性，形成新类型。

interface User {
  id: number;
  name: string;
  email: string;
}

type UserPreview = Pick<User, "id" | "name">;
// { id: number; name: string }

Omit<T, K>

从类型 T 中去掉某些属性，形成新类型。

interface User {
  id: number;
  name: string;
  password: string;
}

type PublicUser = Omit<User, "password">;
// { id: number; name: string }

Record<K, T>

构造一个对象类型，键是 K，值是 T。

type Role = "admin" | "user" | "guest";
type Permissions = Record<Role, boolean>;
// { admin: boolean; user: boolean; guest: boolean }

Exclude<T, U>

从联合类型 T 中排除能赋值给 U 的部分。

type T = "a" | "b" | "c";
type WithoutB = Exclude<T, "b">;
// "a" | "c"

Extract<T, U>

从联合类型 T 中提取能赋值给 U 的部分。

type T = "a" | "b" | "c";
type OnlyB = Extract<T, "b" | "x">;
// "b"

NonNullable<T>

去掉 null 和 undefined。

type T = string | null | undefined;
type SafeT = NonNullable<T>;
// string

ReturnType<T>

获取函数返回值的类型。

function getUser() {
  return { id: 1, name: "Alice" };
}

type User = ReturnType<typeof getUser>;
// { id: number; name: string }

Parameters<T>

获取函数参数的类型，返回一个元组。

function greet(name: string, age: number) {}

type Params = Parameters<typeof greet>;
// [name: string, age: number]

ConstructorParameters<T>

获取构造函数的参数类型，返回一个元组。

class User {
  constructor(public id: number, public name: string) {}
}

type Params = ConstructorParameters<typeof User>;
// [id: number, name: string]

InstanceType<T>

获取构造函数实例的类型。

class User {
  constructor(public id: number, public name: string) {}
}

type UserInstance = InstanceType<typeof User>;
// User

ThisType<T>

为对象字面量指定 this 的类型。常用于 mixin 模式。

type Helper = { name: string };
let obj: ThisType<Helper> & { greet(): void } = {
  greet() {
    console.log(this.name); // this 被推断为 Helper
  },
};

Awaited<T>

获取 Promise 中的解析值类型（TS4.5+）。

type A = Awaited<Promise<string>>; // string
type B = Awaited<Promise<Promise<number>>>; // number

ReadonlyArray<T>

一个数组的只读版本。

const arr: ReadonlyArray<number> = [1, 2, 3];
arr[0] = 10; // ❌ 报错，不能修改

ReadonlyMap<K, V>

ReadonlySet<T>

只读的 Map 和 Set，避免误操作。