TS 内置的 所有工具类型

Partial<T>

将 T 中的所有属性设置为可选

type Partial<T> = { [P in keyof T]?: T[P] | undefined; }

eg:
interface User {
  name: string;
  sex: string;
  age: number;
}
type NewType = Partial<User>;

re:
type NewType = {
    name?: string | undefined;
    sex?: string | undefined;
    age?: number | undefined;
}

Readonly<T>

将 T 中的所有属性设置为只读

type Readonly<T> = { readonly [P in keyof T]: T[P]; }

eg:
interface User {
  name: string;
  sex: string;
  age: number;
}
type NewType = Readonly<User>;

re:
type NewType = {
    readonly name: string;
    readonly sex: string;
    readonly age: number;
}

Required<T>

将 T 中的所有属性设置为必须

type Required<T> = { [P in keyof T]-?: T[P]; }

-? 表示取消可选

eg:
interface User {
  name: string;
  sex？: string;
  age？: number;
}
type NewType = Required<User>;

re:
type NewType = {
    name: string;
    sex: string;
    age: number;
}

Pick<T, K>

从 T 中，选择一组位于 K 中的属性

type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};

eg:
interface User {
  name: string;
  sex: string;
  age: number;
}
type NewType = Pick<User, 'name' | 'sex'>;

re:
type NewType = {
    name: string;
    sex: string;
}

Exclude<T, U>

从 T 中排除可分配给 U 的类型

type Exclude<T, U> = T extends U ? never : T;

eg:
interface User {
  name: string;
  sex: string;
  age: number;
}
type NewType = Exclude<keyof User, 'name' | 'sex'>;

re:
type NewType = "age"

Extract<T, U>

从 T 中提取可分配给 U 的类型

type Extract<T, U> = T extends U ? T : never;

eg:
interface User {
  name: string;
  sex: string;
  age: number;
}
type NewType = Extract<keyof User, 'name' | 'sex'>;

re:
type NewType = "name" | "sex"

Omit<T, K>

构造一个属性为 T 的类型，但类型 K 中的属性除外

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

eg:
interface User {
  name: string;
  sex: string;
  age: number;
}
type NewType = Omit<User, 'name' | 'sex'>;

re:
type NewType = {
    age: number;
}

Record<T, K>

使用类型为 T 的一组属性 K 构造一个类型

type Record<K extends keyof any, T> = {
    [P in K]: T;
};

eg:
interface User {
  name: string;
  sex: string;
  age: number;
}
type NewType = Record<string, User>;

re:
type NewType = {
    [x: string]: User;
}

NonNullable<T>

从 T 中排除 null 和 undefined

type NonNullable<T> = T extends null | undefined ? never : T;

eg:
type name = string | null | undefined;
type newType = NonNullable<name>;

re:
type newType = string

ReturnType<T>

获取函数类型的返回类型

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

eg:
interface User {
  name: string;
  sex: string;
  age: number;
  getFamily: (name: string) => User[];
}
type NewType = ReturnType<User['getFamily']>;

re:
type NewType = User[]

Parameters<T>

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

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

eg:
interface User {
  name: string;
  sex: string;
  age: number;
  getFamily: (name: string) => User[];
}
type NewType = ReturnType<User['getFamily']>;

re:
type NewType = [name: string]

InstanceType<T>

获取构造函数函数类型的返回类型

type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;

eg:
type NewType = InstanceType<new (name: string) => { name: string; age: number }>;

re:
type NewType = {
    name: string;
    age: number;
}

ConstructorParameters<T>

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

type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;

eg:
type NewType = ConstructorParameters<new (name: string) => { name: string; age: number }>;

re:
type NewType = [name: string]

大小写

type NewType = Uppercase<'aaa'>; // AAA  全大写
type NewType = Lowercase<'AAA'>; // aaa   全小写
type NewType = Capitalize<'aaa'>; // Aaa   首字母大写
type NewType = Uncapitalize<'AAA'>; // aAA   首字母小写