Skip to content

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

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

使用场景

typescript
// 账号属性
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

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

Readonly

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

Pick<T,K>

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

使用场景:

typescript
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>

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

使用场景:

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

Exclude<T, U>

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

使用场景:

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

Extract<T, U>

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

使用场景:

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

Omit<T, K>

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

使用场景:

typescript
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

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

使用场景

typescript
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

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

使用场景:

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

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

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

typescript
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

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

使用场景

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

ReturnType

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

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

InstanceType

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

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