Appearance
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> 类似,不再赘述