工具类

1. 基本修饰工具类型

// 所有属性变为可选
type Partial<T> = {
  [P in keyof T]?: T[P];
};

// 所有属性变为必选
type Required<T> = {
  [P in keyof T]-?: T[P];
};

// 所有属性变为只读
type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

2. 嵌套修饰工具类型

// 深度所有属性可选
type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

interface User {
  name: string;
  address: {
    city: string;
    zip: number;
  };
}

type PartialUser = DeepPartial<User>;
// { name?: string; address?: { city?: string; zip?: number; } }

// 深度所有属性只读
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

3. 选择性修饰工具类型

interface User {
  name: string;
  age: number;
  email: string;
}
// Pick<T, K> - 选择特定属性
type UserBasic = Pick<User, 'name' | 'email'>;
// { name: string; email: string; }

// Omit<T, K> - 排除特定属性
type UserWithoutEmail = Omit<User, 'email'>;
// { name: string; age: number; }

4. 属性特性修改工具类型

// Mutable<T> - 移除只读修饰符（需要自定义）
type Mutable<T> = {
  -readonly [P in keyof T]: T[P];
};

interface ReadonlyUser {
  readonly name: string;
  readonly age: number;
}

type WritableUser = Mutable<ReadonlyUser>;
// { name: string; age: number; }

// NonNullable<T> - 移除 null 和 undefined
type MaybeString = string | null | undefined;
type DefinitelyString = NonNullable<MaybeString>; // string

5. 记录类型工具

type UserMap = Record<string, User>;
// { [key: string]: User; }

type SpecificKeys = Record<'admin' | 'user', User>;
// { admin: User; user: User; }

6. 条件修饰工具类型

// 使某些属性可选
type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

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

type UserWithOptionalEmail = MakeOptional<User, 'email'>;
// { name: string; age: number; email?: string; }

// 条件性添加只读
type MakeReadonly<T, K extends keyof T> = Omit<T, K> & Readonly<Pick<T, K>>;

type UserWithReadonlyName = MakeReadonly<User, 'name'>;
// { readonly name: string; age: number; email: string; }

7. 实用组合工具类型

type T = string | number | boolean;

// 交集
type StringOrNumber = Extract<T, string | number>; // string | number

// 差集
type WithoutBoolean = Exclude<T, boolean>; // string | number

// 并集
type Concurrence<A, B> = A | B;

// 交集
type Intersection<A, B> = A extends B ? A : never;

// 差集
type Difference<A, B> = A extends B ? never : A;

// 补集
type Complement<A, B extends A> = Difference<A, B>;

其他泛型

// Replace 工具类型通常用于替换元组中的某个元素类型
type Replace<T extends any[], U, V> = {
  [K in keyof T]: T[K] extends U ? V : T[K];
};

// 使用 Replace 工具类型
type OriginalTuple = [string, number, boolean];
type NewTuple = Replace<OriginalTuple, number, string>;

// NewTuple 的类型为 [string, string, boolean]