ts 内置工具类型（Partial、Pick、Record、Readonly、Exclude、Extract、Omit等）
- 参考链接：https://blog.csdn.net/qq_43869822/article/details/121664818
- typescript 源码可在包目录（如 node_modules）中
lib.es5.d.ts文件中查看
概要
-
可选
Partial、必选Required、只读Readonly -
过滤、剔除：
Exclude、Extract、Pick、Omit -
约束对象的 key 和 value：
Record -
去除 null 和 undefined：
NonNullable -
函数参数类型：
Parameters、ConstructorParameters -
函数返回值类型：
ReturnType、InstanceType
一、Partial
1、作用
生成一个 新类型，与老类型的 属性全部相同，但是都变为 可选
2、源码
type Partial<T> = {
[P in keyof T]?: T[P];
}
keyof T：拿出 T 中所有的 key，作为一个联合类型in：表循环，类似于for...inP in keyof T：则 P 就代表了 T 中每个 key
3、使用
type Person = {
name: string
age: number
sex: string
}
type Par = Partial<Person>
// 鼠标放上Par，可发现每个属性都加了一个 ?，如下：
// type Par = {
// name?: string;
// age?: number;
// sex?: string;
// }
二、Required
1、作用
生成一个 新类型，与老类型的 属性全部相同，但是都变为 必选
2、源码
type Required<T> = {
[P in keyof T]-?: T[P];
};
- 与 Partial 相似，这里是
去掉 ?
3、使用
type Person = {
name ?: string
age: number
sex ?: string
}
type Req = Required<Person>
// 鼠标放上Req，可发现每个属性都是必填，如下：
// type Req = {
// name: string;
// age: number;
// sex: string;
// }
三、Readonly
1、作用
生成一个 新类型，与老类型的 属性全部相同，但是都变为 只读
2、源码
type Readonly<T> = {
readonly [P in keyof T]: T[P];
};
- 每个属性前增加关键字
readonly 可选特性会被保留
3、使用
type Person = {
name: string
age: number
sex?: string
}
type Read = Readonly<Person>
// 鼠标放上Read，可发现每个属性都是只读，如下：(sex仍然是可选)
// type Read = {
// readonly name: string;
// readonly age: number;
// readonly sex?: string;
// }
四、Exclude
1、作用
- 如果 T 是 U 的子类型则返回
never不是则返回T - 白话就是：从 T 出
剔除U 包含的类型
2、源码
type Exclude<T, U> = T extends U ? never : T
T extends U：T 是 U 的子类型- 以
T 的单个去对比U 的全部
3、使用
type A = string | number | boolean
type B = string | boolean | symbol
type C = string
type exc = Exclude<A, B>
// type exc = number
type exc2 = Exclude<A, C>
// type exc2 = number | boolean
五、Extract（与 Exclude 相反）
1、作用
- 如果 T 是 U 的子类型则返回
T不是则返回never - 白话就是：从 T 中
选出U 包含的类型
2、源码
type Extract<T, U> = T extends U ? T : never;
与 Exclude 相反，不做过多赘述
3、使用
type D = string | number | boolean
type E = number
type F = string | number | symbol
type ext = Extract<D, E>
// type ext = number
type ext2 = Extract<D, F>
// type ext2 = string | number
六、Pick
1、作用
生成一个 新类型，取出老类型中的 指定属性 及 它对应的类型
2、源码
type Pick<T, K extends keyof T> = {
[P in K]: T[P];
};
K extends keyof T：将K约束为T 中的 key构成，重要！
3、使用
type Person = {
name: string
age: number
sex: string
}
type Pic = Pick<Person, 'name' | 'age'>
// 取出的就是指定 key 所组成的映射
// type Pic = {
// name: string;
// age: number;
// }
七、Omit（剔除）
1、作用
生成一个 新类型，从老类型中 剔除 的 指定属性 及 它对应的类型
2、源码
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
// 也有这样的源码版本，是一个意思
type Omit<T, K extends string | number | symbol> = {
[P in Exclude<keyof T, K>]: T[P];
}
- 与
Pick看似相反，但不严格相反，因为这里的 K 不限制为 T 中的 key 构成 K extends keyof any等价于K extends string | number | symbol
3、使用
type Person3 = {
name ?: string
age: number
readonly sex: string
hobby: string
height: number
}
// 第二个参数可以传无关的 'weight'
type per3 = Omit<Person3, 'hobby' | 'height' | 'weight'>
// type per3 = {
// name?: string;
// age: number;
// readonly sex: string;
// }
八、Record
1、作用
限制 对象 中 key 的取值、value 的类型
2、源码
type Record<K extends keyof any, T> = {
[P in K]: T;
};
3、使用
// 使用示例 1：第一个参数如果传具体的 key, 使用时每个 key 需要被具体设置
type Rec = Record<'A' | 'B' | 'C', number>
// type Rec = {
// A: number;
// B: number;
// C: number;
// }
let obj: Rec = {
A: 1,
B: 2,
C: 10
}
// 使用示例 2：第一个参数当然可以是 string | number | symbol 的任意类型联合的值
type Rec2 = Record<'A' | 2, boolean>
// type Rec2 = {
// A: boolean;
// 2: boolean;
// }
let obj2: Rec2 = {
A: true,
2: false
}
// 使用示例 3：第一个参数如果传类型，使用时每个key都要对应上这个类型
type Rec3 = Record<string, number>
// type Rec3 = {
// [x: string]: number
// }
let obj3: Rec3 = {
A: 1,
B: 2,
C: 3
}
// 使用示例 4：第一个参数也可以传联合类型
type Rec4 = Record<number | symbol, boolean>
// type Rec4 = {
// [x: number]: boolean;
// [x: symbol]: boolean;
// }
let obj4: Rec4 = {
1: true,
[Symbol('111')]: false,
2: false,
// 'a': false // 报错，key类型不是 number 或 symbol
}
// 使用示例 5：路由信息的使用
type page = 'home' | 'login' | 'user'
type pageInfo = {
title: string,
needLogin: boolean
}
let obj5: Record<page, pageInfo> = {
home: { title: '1111', needLogin: false },
login: { title: '1111', needLogin: false },
user: { title: '1111', needLogin: true },
}
九、NonNullable
1、作用
从泛型 T 中 排除掉 null 和 undefined
2、源码
type NonNullable<T> = T extends null | undefined ? never : T;
3、使用
type nonBefore = string | undefined | boolean | null | never
type non = NonNullable<nonBefore>
// type non = string | boolean
十、Parameters
1、作用
以 元组 的方式获得 函数的入参类型
2、源码
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
- infer 的作用单独用一篇学习，这里先记住，是将参数另外起名为 P
3、使用
type Para = Parameters<(name: string, age: number) => any>
// type Para = [name: string, age: number]
const para: Para = ['abc', 123]
十一、ConstructorParameters
1、作用
以 元祖 的方式获得 构造函数的入参类型
2、源码
type ConstructorParameters<T extends new (...args: any) => any> = T extends new (...args: infer P) => any ? P : never;
3、使用
type Con = ConstructorParameters<new (name: string) => any>
// type Con = [name: string]
const con: Con = ['blue']
// 联合类型
type Con2 = ConstructorParameters<(new (name: string) => any) | (new (age: number) => number)>
// type Con2 = [name: string] | [age: number]
const con2: Con2 = ['blue']
const con22: Con2 = [123]
// 多个参数
type Con3 = ConstructorParameters<new (name: string, age: number) => any>
// type Con3 = [name: string, age: number]
const con3: Con3 = ['blue', 123]
十二、ReturnType
1、作用
获得 函数 返回值的类型
2、源码
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
3、使用
// 使用
type Ret = ReturnType<() => void>
// type Ret = void
type Ret2 = ReturnType<() => boolean>
// type Ret2 = boolean
type Ret3 = ReturnType<() => string | number>
// type Ret3 = string | number
十三、InstanceType
1、作用
获得 构造函数 返回值的类型
2、源码
type InstanceType<T extends new (...args: any) => any> = T extends new (...args: any) => infer R ? R : any;
3、使用
// 使用
type Ins = InstanceType<new () => number>
// type Ins = number
End: 附13个type源码合集
/**
* Make all properties in T optional
*/
type Partial<T> = {
[P in keyof T]?: T[P];
};
/**
* Make all properties in T required
*/
type Required<T> = {
[P in keyof T]-?: T[P];
};
/**
* Make all properties in T readonly
*/
type Readonly<T> = {
readonly [P in keyof T]: T[P];
};
/**
* From T, pick a set of properties whose keys are in the union K
*/
type Pick<T, K extends keyof T> = {
[P in K]: T[P];
};
/**
* Construct a type with a set of properties K of type T
*/
type Record<K extends keyof any, T> = {
[P in K]: T;
};
/**
* Exclude from T those types that are assignable to U
*/
type Exclude<T, U> = T extends U ? never : T;
/**
* Extract from T those types that are assignable to U
*/
type Extract<T, U> = T extends U ? T : never;
/**
* Construct a type with the properties of T except for those in type K.
*/
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
/**
* Exclude null and undefined from T
*/
type NonNullable<T> = T extends null | undefined ? never : T;
/**
* Obtain the parameters of a function type in a tuple
*/
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
/**
* Obtain the parameters of a constructor function type in a tuple
*/
type ConstructorParameters<T extends new (...args: any) => any> = T extends new (...args: infer P) => any ? P : never;
/**
* Obtain the return type of a function type
*/
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
/**
* Obtain the return type of a constructor function type
*/
type InstanceType<T extends new (...args: any) => any> = T extends new (...args: any) => infer R ? R : any;