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>	移除 T 中的 U 属性
NonNullable	排除类型 T 的 null | undefined 属性
Parameters	获取一个函数的所有参数类型
ConstructorParameters	类似于 Parameters<T>, ConstructorParameters 获取一个类的构造函数参数
ReturnType	获取函数类型 T 的返回类型
InstanceType	获取一个类的返回类型

目录

Partial

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

使用场景

// 账号属性
enum Vip {
  not = 0, // 非 vip
  advanced = 1 // 高级 vip
}

interface AccountInfo {
  name: string
  age: number
  email: string
  vip?: Vip
}

// render table
const accountTableList: AccountInfo[] = []

// filter accountInfo form
const model: Partial<AccountInfo> = {
  name: '高级 vip 用户',
  vip: Vip.advanced
}

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]
}

使用场景

// 账号属性
enum Vip {
  not = 0, // 非 vip
  advanced = 1 // 高级 vip
}

interface AccountInfo {
  name: string
  age: number
  email: string
  vip?: Vip
}

type CoreInfo = Pick<AccountInfo, 'name' | 'email'>

Record<K, T>

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

使用场景

// 账号属性
enum Vip {
  not = 0, // 非 vip
  advanced = 1 // 高级 vip
}

interface AccountInfo {
  name: string
  age: number
  email: string
  vip?: Vip
}

const accountMap: Record<number, AccountInfo> = {
  10001: {
    name: 'xx',
    age: 0,
    email: 'xxxxx',
    vip: Vip.not
  },
}
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
Type 'number' is not assignable to type '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>

Omit<T, K>

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

使用场景

interface Student {
  name: string
  age: number
  classes: string
  school: string
}
type PersonAttributes = 'name' | 'age'
type OmitStudent = Omit<Student, PersonAttributes>

NonNullable

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

使用场景

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

function fn<T extends string | undefined>(x: T, y: NonNullable<T>) {
  let s1: string = x
Type 'string | undefined' is not assignable to type 'string'.
  Type 'undefined' is not assignable to type 'string'.
  let s2: string = y
}

Parameters

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

使用场景

interface Person {
  name: string
  age: number
  nationality: string
  id_card: string
}

interface Func {
  (person: Person, count: number): boolean
}

type P = Parameters<Func>

// 快速获取未知函数的参数类型
function add (a: number, b: number) {
  return a + b
}
// 其他库导入的函数，获取其参数类型
type FuncParams = Parameters<typeof add>
// 内置函数
type FillParams = Parameters<typeof Array.prototype.fill>

ConstructorParameters

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

使用场景

type DateConstrParams = ConstructorParameters<typeof Date>

ReturnType

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

InstanceType

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