内置工具类型

Partial

Partial<T> 将类型的属性变成可选，只处理第一层数据

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

interface UserInfo {
  id: string;
  name: string;
}
type NewUserInfo = Partial<UserInfo>
/*
interface NewUserInfo {
    id?: string;
    name?: string;
}
*/

DeepPartial

DeepPartial<T> 将类型的属性变成可选，会递归处理

type DeepPartial<T> = {
     // 如果是 object，则递归类型
    [U in keyof T]?: T[U] extends object
      ? DeepPartial<T[U]>
      : T[U]
};

Required

Required：类型属性变成必选

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

-?：代表移除 ？（可选）

Readonly

Readonly：属性添加只读，引用类型仍然可以改

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

Pick

Pick：从某个类型中挑出一些属性出来

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

interface Todo {
  title: string;
  description: string;
  completed: boolean;
}

type TodoPreview = Pick<Todo, 'title' | 'completed'>

/*
interface TodoPreview {
  
title: string;
  completed: boolean;
}
*/

Record

Record<K extends keyof any, T> ：将 K 中所有的属性的值转化为 T 类型。

K extends keyof any：表示 K 为索引类型

keyof any ：string | number | symbol

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

interface PageInfo {
  title: string;
}

type Page = 'home' | 'about' | 'contact'

const x: Record<Page, PageInfo> = {
  about: {
    title: 'about'
  },
  contact: {
    title: 'contact'
  },
  home: {
    title: 'home'
  }
}
/*
interface Page {
   home: PageInfo;
   about: PageInfo;
   contact: PageInfo;
}
*/

ReturnType

ReturnType：获取函数返回值类型

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

infer R：推断返回值类型。T 是函数，返回函数返回值类型，否则返回 any

Exclude

Exclude<T, U> ：将 T 类型中属于 U 类型的移除掉

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

type T0 = Exclude<'a' | 'b' | 'c', 'a'> // "b" | "c"
type T1 = Exclude<'a' | 'b' | 'c', 'a' | 'b'> // "c"
type T2 = Exclude<string | number | (() => void), Function> // string | number

Extract

Extract<T, U>：将 T 类型 从 U 类型中取出

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

type T0 = Extract<'a' | 'b' | 'c', 'a' | 'f'> // "a"
type T1 = Extract<string | number | (() => void), Function> // () =>void

Omit

Omit<T, K extends keyof any> ：使用 T 类型中除了 K 类型的所有属性，来构造一个新的类型。

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

interface Todo {
  title: string;
  description: string;
  completed: boolean;
}

type TodoPreview = Omit<Todo, 'description'>

interface TodoPreview {
  title: string;
  completed: boolean;
}

NonNullable

NonNullable<T> ：用来过滤类型中的 null 及 undefined 类型。

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

type T0 = NonNullable<string | number | undefined> // string | number
type T1 = NonNullable<string[] | null | undefined> // string[]

Parameters

Parameters<T> ：获得函数的参数类型组成的元组类型。

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

type A = Parameters<() => void> // []
type B = Parameters<typeof Array.isArray> // [any]
type C = Parameters<typeof parseInt> // [string, (number | undefined)?]
type D = Parameters<typeof Math.max> // number[]