TypeScript 内置工具类型

Partial T : 将接口的所有元素都变成可选

// Partial<T>
interface Order {
  id: string;
  createTime: number;
}
type MyPartial<T> = { [P in keyof T]?: T[P] }
type TypeOrder1 = Partial<Order>;
type TypeOrder2 = MyPartial<Order>;
// 输出
// TypeOrder1 = TypeOrder2
// {
//  id?: string;
//  createTime?: number;
// }

Require T : 将接口的所有元素都变成必填

type Order2 = {
    id: string,
    createTime?: number;
}
type MyRequired<T> = {[K in keyof T]-?: T[K]}
type Type1 = Required<Order2>
type Type2 = MyRequired<Order2>
// 输出 
// {
//  id: string,
//  createTime?: number;
// }

Readonly T: 将接口所有元素变成readonly

// Readonly<T>
interface Order {
  id: string;
  createTime: number;
}
type MyReadonly<T> = { readonly [P in keyof T ]: T[P]};
type TypeOrder1 = Readonly<Order>;
type TypeOrder2 = MyReadonly<Order>;
// TypeOrder1 = TypeOrder2
// {
//  readonly id: string;
//  readonly createTime: number;
// }

Record T,U ：将接口所有元素类型定为U

// Record<T, U>
interface Order {
  id: string;
  createTime: number;
}
type OrderType = "pending" | "finished" | "created";
type MyRecord<T extends string | number | symbol, U> = { [ P in T]: U} 
type TypeOrder1 = Record<OrderType, Order>;
type TypeOrder2 = MyRecord<OrderType, Order>;
// 输出
// {
//   pending: Order;
//   finished: Order;
//   created: Order;
// }

Exclude T,U: 在类型T中剔除满足类型U的类型

type MyExclude<T,U> = T extends U ? never : T; 
type Type1 = Exclude<'a' | 'b' | 'c', 'c'>;
type Type2 = TypeExclude<'a' | 'b' | 'c', 'c'>;
// 输出 'a', 'b'

Extract T,U : 从类型T选择满足类型U

type MyExtract<T, U> = T extends U ? T : never; 
type Type1 = Extract<'a'|'b'|'c', 'c'>
type Type2 = MyExtract<'a'|'b'|'c', 'c'>
// 输出 'c'

Pick T,U ：从接口中选取目标（U）类型

Pick<T, U>
interface Order {
  id: string;
  createTime: number;
}
type MyPick<T, U extends number | string | symbol> = { [K in U]: T[K]};
type TypeCreateTime1 = Pick<Order, 'createTime'>;
type TypeCreateTime2 = MyPick<Order, 'createTime'>;
// 输出
// {createTime: number}

Omit T,U: 与Pick相反，从T中剔除掉key满足U的元素

interface Order {
  id: string;
  createTime: number;
}
type MyOmit<T, U extends number | string | symbol> = { [K in Exclude<keyof T, U>]: T[K]}
type Type1 = Omit<Order,  'createTime'>
type Type2 = MyOmit<Order, 'createTime'>
// 输出
//  {
//   id: string;
// }

Parameters T: 获取函数传参类型

type Fn = (param: string, config: {}) => string;
type MyParamters<T extends (...args: any) => any> = T extends (...args: infer U) => any ? U : never;
type Type3 = Parameters<Fn>;
type Type4 = MyParamters<Fn>;
// 输出  [param: string, config: {}]

ReturnType T: 获取函数返回类型

type Fn = (param: string) => string;
type MyReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer U ? U : never;
type Type3 = ReturnType<Fn>;
type Type4 = MyReturnType<Fn>;
// 输出 string

NonNullable

InstanceType