Fork me on GitHub

TypeScript中一些被忽视的内置类型

ts 中其实已经内置了很多常用类型,此处记录一下,不是太完整 🐶

假设我们已经声明了一个 interface

1
2
3
4
interface Person {
name: string
age?: number
}

Partial

将所有参数变成可选

1
2
3
4
5
type Partial<T> = {
[P in keyof T]?: T[P]
}

// Partial<Person> -> { name?: string; age?: number }

Required

将所有参数变成必选

1
2
3
4
5
type Required<T> = {
[P in keyof T]-?: T[P]
}

// Required<Person> -> { name: string; age: number }

Readonly

将所有参数变成只读

1
2
3
4
5
type Readonly<T> = {
readonly [P in keyof T]: T[P]
}

// Readonly<Person> -> { readonly name: string; readonly age?: number }

Pick

挑出一部分属性及声明重新生成一个新类型

1
2
3
4
5
6
type Pick<T, K extends keyof T> = {
[P in K]: T[P]
}

// Pick<Person, 'name'> -> { name: string }
// Pick<Person, 'name' | 'age> -> { name: string; age?: number }

Record

构造一个具有一组属性为 K,类型为 T 的类型

1
2
3
4
5
type Record<K extends keyof any, T> = {
[P in K]: T
}

// Record<'a' | 'b' | 'c', Person> -> { a: Person; b: Person; c: Person; }

Exclude

从 T 中排除那些可赋值给 U 的类型

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

// Exclude<'admin' | 'guest', 'guest'> -> "admin"

Extract

从 T 中提取那些可赋值给 U 的类型

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

// Extract<'admin' | 'guest', 'guest'> -> "guest"

Omit

用来忽略对象某些属性

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

// Omit<Person, 'age'> -> { name: string }

NonNullable

从 T 中排除 null 和 undefined

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

// NonNullable<'a' | 'b' | null> -> "a" | "b"

Parameters

获取函数的参数类型组成的元组类型

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

function foo(a: string, b: number) {}
// Parameters<typeof foo> -> [string, number]

ReturnType

获取函数的返回类型

1
2
3
4
5
6
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any

function foo(x: number): number[] {
return [x]
}
// ReturnType<typeof foo> -> number[]