Ts 的内置类型

名称	描述
Partial	将类型 T 的所有属性标记为可选属性
Required	与 Partial 相反，Required 将类型 T 的所有属性标记为必选属性
Readonly	将所有属性标记为 readonly, 即不能修改
Pick<T, K>	从 T 中过滤出属性 K
Record<K, T>	标记对象的 key value 类型
Exclude<T, U>	移除 T 中的 U 属性
Extract<T, U>	Exclude 的反操作，取 T，U 两者的交集属性
Omit<T, K>	传入一个类型，和这个类型的几个属性，把传入的属性省略掉，组成一个新类型
NonNullable	排除类型 T 的 null | undefined 属性
Parameters	获取一个函数的所有参数类型
ConstructorParameters	类似于 Parameters<T>, ConstructorParameters 获取一个类的构造函数参数
ReturnType	获取函数类型 T 的返回类型
InstanceType	获取一个类的返回类型

Partial

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

使用场景

// 账号属性
interface AccountInfo {
  name: string
  email: string
  age: number
  vip: 0 | 1 // 1 是vip ，0 是非vip
}

// 当我们需要渲染一个账号表格时，我们需要定义
const accountList: AccountInfo[] = []

// 但当我们需要查询过滤账号信息，需要通过表单，
// 但明显我们可能并不一定需要用到所有属性进行搜索，此时可以定义
const model: Partial<AccountInfo> = {
  name: '',
  vip: undefined,
}

Required

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

Readonly

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

Pick<T,K>

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

使用场景:

interface AccountInfo {
  name: string
  email: string
  age: number
  vip?: 0 | 1 // 1 是vip ，0 是非vip
}

type CoreInfo = Pick<AccountInfo, 'name' | 'email'>
/* 
{ 
  name: string
  email: string
}
*/

Record<K,T>

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

使用场景:

// 定义 学号(key)-账号信息(value) 的对象
const accountMap: Record<number, AccountInfo> = {
  10001: {
    name: 'xx',
    email: 'xxxxx',
    // ...
  },
}
const user: Record<'name' | 'email', string> = {
  name: '',
  email: '',
}

Exclude<T, U>

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

使用场景:

type message = string | number
type ExcludeInfo = Exclude<message, number>
let excludeInfo: ExcludeInfo = 200 //Error:不能将类型“number"分配给类型“string"。

Extract<T, U>

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

使用场景:

type message = string | number | boolean | Date
type ExtractMessage = Extract<message, boolean | number | Function>
// 等价于
type ExtractMessage = number | boolean

Omit<T, K>

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

使用场景:

interface Student {
  name: string
  age: number
  class: string
  school: string
}
type PersonAttr = 'name' | 'age'
type OmitStudent = Omit<Student, PersonAttr>
// 等价于下面
type OmitStudent = {
  class: string
  school: string
}

NonNullable

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

使用场景

type A = string | number | undefined
type B = NonNullable<A> // string | number

function f2<T extends string | undefined>(x: T, y: NonNullable<T>) {
  let s1: string = x // Error, x 可能为 undefined
  let s2: string = y // Ok
}

Parameters

// 此处使用 infer P 将参数定为待推断类型
// T 符合函数特征时，返回参数类型，否则返回 never
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never

使用场景:

interface IFunc {
  (person: IPerson, count: number): boolean
}

type P = Parameters<IFunc> // [IPerson, number]

另一种使用场景是，快速获取未知函数的参数类型

import { somefun } from 'somelib'
// 从其他库导入的一个函数，获取其参数类型
type SomeFuncParams = Parameters<typeof somefun>

// 内置函数
// [any, number?, number?]
type FillParams = Parameters<typeof Array.prototype.fill>
// 等价于
type FillParams = [value: any, start?: number | undefined, end?: number | undefined]

ConstructorParameters

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

使用场景

type DateConstrParams = ConstructorParameters<typeof Date>
// 等价于
type DateConstrParams = [value: string | number | Date]

ReturnType

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

使用方式和 Parameters<T> 类似，不再赘述

InstanceType

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

使用方式和 ConstructorParameters<T> 类似，不再赘述