typescript 文档阅读笔记-Utility Types

Partial< Type >

返回一个所有 property 都可选的 type。

// 内部实现
type Partial<T> = {
    [P in keyof T]?: T[P]
}
// 使用
interface Todo {
  title: string;
  description: string;
}
const newTodo: Partial<Todo> = {
    title: 'title'
}

Readonly< Type >

返回一个所有 property 只读的 type

// 内部实现
type Readonly<T> = {
    readonly [P in keyof T]: T[P]
}

Record< Keys, Type >

返回一个类型，key 的类型必须是 Keys，value 的类型必须是 Type

type Record<K extends number|string|symbol, T> = {
    [P in K]: T
}

Pick<Type, Keys>

从 Type 中挑选出 Keys 中指定 key 在 Type 中存在的类型，组成一个新类型

// 内部实现
type Pick<T, K extends keyof T> = {
    [P in K]: T[P]
}

Omit<Type, Keys>

从排除 Type 的 property 中排除 keys 中指定的 property。Type 中剩下的 properties 形成一个新类型。

// 内部实现
type Omit<T, K extends string|number|undefined> = {
    [P in Exclude<keyof T, K>]: T[P]
}

Exclude<Type, ExcludedUnion>

排除两个联合类型共有的部分，Type 排除共有部分剩下的联合类型组成一个新类型。

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

Extract<Type, Union>

取两个联合类型的交集

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

NonNullable< Type >

去掉联合类型中的 null 和 undefined 类型

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

Required< Type >

使 Type 中所有属性必选。

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

Parameters< Type >

返回一个函数类型的参数的类型，值为元祖类型

type T0 = Parameters<() => string>;
//    ^ = type T0 = []
type T1 = Parameters<(s: string) => void>;
//    ^ = type T1 = [s: string]
type T2 = Parameters<<T>(arg: T) => T>;
//    ^ = type T2 = [arg: unknown]
type T4 = Parameters<any>;
//    ^ = type T4 = unknown[]

// 内部实现
type  Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never

ConstructorParameters< Type >

获取构造函数的参数类型

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

InstanceType< Type >

获取构造函数的实例类型，其实就是构造函数的返回值

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

ReturnType< Type >

获取返回值的类型

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

ThisParameterType< Type >

获取函数的 this 类型

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

OmitThisParameter< Type >

如果一个函数有指定 this 类型，那么会返回一个不带该 this 类型的函数类型。否则还是原来的函数

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