TypeScript 内置工具类型

TypeScript 提供了以下几种实用工具类型来帮助常见的类型转换

Awaited<Type> 获取 Promise 返回值类型

Awaited<Type> 可以用来获取 Promise 返回值类型

type Awaited<T> = T extends Promise<infer U> ? U : T

举 🌰

type result = Awaited<Promise<string>>
// 结果：string

Partial<Type> 可选

Partial<Type> 用于将 Type 中的所有属性设置为可选

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

举 🌰

type result = Partial<{ name: string; age: number }>
// 结果：{ name?: string; age?: number }

Required<Type> 必选

Required<Type> 用于将 Type 中的所有属性设置为必选

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

举 🌰

type result = Required<{ name?: string; age?: number }>
// 结果：{ name: string; age: number }

Readonly<Type> 只读

Readonly<Type> 用于将 Type 中的所有属性设置为只读（被 readonly 所修饰）

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

举 🌰

type result = Readonly<{ name: string; age: number }>
// 结果：{ readonly name: string; readonly age: number }

Record<Keys, Type> 构造对象

Record<Keys, Type> 用于构造一个由 Keys 中的属性决定 Type 中属性类型的对象

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

举 🌰

type result = Record<'a' | 'b', string>
// 结果：{ a: string; b: string }

Pick<Type, Keys> 选取

Pick<Type, Keys> 用于从类型 Type 中选取指定的几个字段 Keys 组合成一个新的类型

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

举 🌰

type result = Pick<{ name: string; age: number }, 'name'>
// 结果：{ name: string }

Exclude<UnionType, ExcludedMembers> 排除

Exclude<UnionType, ExcludedMembers> 用于从联合类型 UnionType 中排除指定的几个成员 ExcludedMembers（即取 UnionType 对于 ExcludedMembers 的差集），来构造一个新的类型

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

举 🌰

type result = Exclude<'name' | 'age' | 'sex', 'sex' | 'address'>
// 结果：'name' | 'age'

Omit<Type, Keys> 移除

Omit<Type, Keys> 用于从类型 Type 中移除指定的几个字段 Keys

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

举 🌰

type result = Omit<{ name: string; age: number }, 'name'>
// 结果：{ age: number }

Extract<Type, Union> 提取

Extract<Type, Union> 用于从联合类型 Type 中提取可赋值给 Union 的类型

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

举 🌰

type result = Extract<'name' | 'age' | 'sex', 'sex' | 'address'>
// 结果：'sex'

NonNullable<Type> 排除 null 和 undefined

NonNullable<Type> 用于从类型 Type 中排除 null 和 undefined

type NonNullable<T> = T & {}

举 🌰

type result = NonNullable<string | null | undefined>
// 结果：string

Parameters<Type> 获取函数参数类型

Parameters<Type> 用于获取函数 Type 的参数类型组成的元组类型

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

举 🌰

type result = Parameters<(name: string, age: number) => void>
// 结果：[name: string, age: number]

ConstructorParameters<Type> 获取构造函数参数类型

ConstructorParameters<Type> 用于获取构造函数 Type 的参数类型组成的元组类型

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

举 🌰

type result = ConstructorParameters<new (name: string, age: number) => void>
// 结果：[name: string, age: number]

ReturnType<Type> 获取函数返回值类型

ReturnType<Type> 用于获取函数 Type 的返回值类型

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

举 🌰

type result = ReturnType<() => string>
// 结果：string

InstanceType<Type> 获取构造函数实例类型

InstanceType<Type> 用于获取构造函数 Type 的实例类型

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

举 🌰

interface Example {
  fn(a: string): string
}

interface ExampleConstructor {
  new (a: string, b: number): Example
}

type result = InstanceType<ExampleConstructor>
// 结果：Example

ThisParameterType<Type> 提取函数的 this 类型

ThisParameterType<Type> 用于提取函数 Type 的 this 参数类型

type ThisParameterType<T> = T extends (this: infer U, ...args: never) => any ? U : unknown

举 🌰

function toHex(this: Number) {
  return this.toString(16)
}

function numberToString(n: ThisParameterType<typeof toHex>) {
  return toHex.apply(n)
}

OmitThisParameter<Type> 忽略 this 参数类型

OmitThisParameter<Type> 用于忽略函数 Type 的 this 参数类型

type OmitThisParameter<T> = unknown extends ThisParameterType<T>
  ? T
  : T extends (...args: infer A) => infer R
  ? (...args: A) => R
  : T

举 🌰

function toHex(this: Number) {
  return this.toString(16)
}

const fiveToHex: OmitThisParameter<typeof toHex> = toHex.bind(5)

console.log(fiveToHex())

ThisType<Type> 设置 this 参数类型

ThisType<Type> 可以在对象字面量中键入 this，并提供通过上下文类型控制 this 类型的便捷方式，其只有在 --noImplicitThis 的选项下才有效

interface ThisType<T> {}

举 🌰

type ObjectDescriptor<D, M> = {
  data?: D
  methods?: M & ThisType<D & M> // Type of 'this' in methods is D & M
}

function makeObject<D, M>(desc: ObjectDescriptor<D, M>): D & M {
  let data: object = desc.data || {}
  let methods: object = desc.methods || {}
  return { ...data, ...methods } as D & M
}

let obj = makeObject({
  data: { x: 0, y: 0 },
  methods: {
    moveBy(dx: number, dy: number) {
      this.x += dx // Strongly typed this
      this.y += dy // Strongly typed this
    },
  },
})

obj.x = 10
obj.y = 20
obj.moveBy(5, 5)

字符串操作类型

一组用于操作字符串的类型

Uppercase<StringType> 将字符串转换为大写

Uppercase<StringType> 将字符串转换为大写

举 🌰

type result = Uppercase<'maomao'>
// 结果：'MAOMAO'

Lowercase<StringType> 将字符串转换为小写

Lowercase<StringType> 将字符串转换为小写

举 🌰

type result = Lowercase<'MAOMAO'>
// 结果：'maomao'

Capitalize<StringType> 将字符串首字母转换为大写

Capitalize<StringType> 将字符串首字母转换为大写

举 🌰

type result = Uncapitalize<'maomao'>
// 结果：'Maomao'

Uncapitalize<StringType> 将字符串首字母转换为小写

Uncapitalize<StringType> 将字符串首字母转换为小写

举 🌰

type result = Uncapitalize<'Maomao'>
// 结果：'maomao'

---

相关资料

Utility Types | TypeScript