1、Partial
源码实现：
type Partial<T> = { [P in keyof T]?: T[P]; };
作用：它用来将 T 中的所有的属性都变成可选的。
案例：
type Animal = { name: string, category: string, age: number, eat: () => number } type PartOfAnimal = Partial<Animal>; const ww: PartOfAnimal = { eat: () => { return 233 } }; // 属性全部可选后，可以只赋值部分属性了
2、Record
源码实现：
type Record<K extends keyof any, T> = { [P in K]: T; };
作用：它用来生成一个属性为 K，属性值类型为 T 的类型集合。
案例：
const obj: Record<string, string> = { 'name': '张三', 'tag': '打工人' } // 正确
const obj1: Record<'a', string> = { 'a': '453' } // 正确
const obj2: Record<'a', string> = { 'b': '453' } // 错误 obj2中没有属性a
3、Required
源码实现：
type Required<T> = { [P in keyof T]-?: T[P]; };
作用：它的作用正好和上面的Partial相反，是将 T 中的所有属性都变成必选的状态。
案例：
interface IFoo { a?: number b?: number } const a: Required<IFoo> = { a: 2, b: 3 } interface IFoo1 { a: number b?: number } const b: Required<IFoo1> = { a: 3, b: 3 }
4、Readonly
源码实现：
type Readonly<T> = { readonly [P in keyof T]: T[P]; };
作用：这个从字面意思就可以理解是将一个类型的所有成员变为只读的状态。
案例：
interface IFoo { name: string age: number } let a:Readonly<IFoo> = { name: '张三', age: 23 } a.age = 24 // 报错，age是只读属性
5、Pick
源码实现：
type Pick<T, K extends keyof T> = { [P in K]: T[P]; };
作用：它的作用是从 T 中将所有的 K 取出来，并生成一个新的类型。
案例：
interface IFoo { name: string age: number height: number } let a:Pick<IFoo,'name'|'age'> = { name: '张三', age: 23 } // 正确。a包含属性name和age let b:Pick<IFoo,'name'|'age'> = { name: '张三', height: 163 } // 报错。a只包含属性name和age，不包含属性height
6、Exclude
源码实现：
type Exclude<T, U> = T extends U ? never : T;
作用：从 T 中排除掉所有包含的 U 属性。
案例：
// 相当于: type A = 'a' type A = Exclude<'x' | 'a', 'x' | 'y' | 'z'> let a: A = 'a' // 正确 let b: A = 'x' // 不能将类型“"x"”分配给类型“"a"” let c: A = 'l' // 不能将类型“"l"”分配给类型“"a"”
7、Extract
源码实现：
type Extract<T, U> = T extends U ? T : never;
作用：正好和上面的Exclude相反。而是从 T 中提取出所有包含的 U 属性值。
案例：
// 相当于: type A = 'x' type A = Extract<'a' | 'x', 'x' | 'y'> let a: A = 'x' // 正确 let b: A = 'a' // 报错：不能将类型“"a"”分配给类型“"x"” let c: A = 'y' // 报错：不能将类型“"y"”分配给类型“"x"”
8、NonNullable
源码实现：
type NonNullable<T> = T extends null | undefined ? never : T;
作用：去除 T 中包含的null或者undefined。
案例：
type A = NonNullable<string | null | undefined> let a: A = '李四' // 正确 let b: A = 3 // 报错：不能将类型“number”分配给类型“string” let c: A = undefined // 报错： 不能将类型“undefined”分配给类型“string”。
9、Parameters
源码实现：
type Parameters<T extends (...args: any[]) => any> = T extends (...args: infer P) => any ? P : never;
作用：用来获取一个函数的参数类型，而且返回的是只能包含一组类型的数组。
案例：
type Func = ({ user: string, age: number }) => void
type Param = Parameters<Func> // 等价与type Param = [{user: any;age: any;}]
let a: Param = [{ user: '1', age: 34 }] // 正确
let b: Param = [{ user: '1', age: 34, height: 45 }] // 报错
let c: Param = [{ user: '1', age: 34,},{ user: '1', age: 34,}] // 报错
10、ConstructorParameters
源码实现：
type ConstructorParameters<T extends new (...args: any[]) => any> = T extends new (...args: infer P) => any ? P : never;
作用：用来获取一个类的构造函数参数类型，并以数组的形式返回。
案例：
class Person { constructor(name: string, age: number) { } } let a: ConstructorParameters<typeof Person> // 相当于 let a: [name: string, age: number] a = ['张三', 34]
11、ReturnType
源码实现：
type ReturnType<T extends (...args: any[]) => any> = T extends (...args: any[]) => infer R ? R : any;
作用：用来得到一个函数的返回值类型。
案例：
type Func = ({ user: string, age: number }) => string
type Param = ReturnType<Func> // 相当于： type Param = string
let a:Param = undefined // 报错 不能将类型“undefined”分配给类型“string”。
let b:Param = '3' // 正确
let c:Param = null // 报错 不能将类型“null”分配给类型“string”。
let d:Param = 2 // 报错 不能将类型“number”分配给类型“string”。
12、InstanceType
源码实现：
type InstanceType<T extends new (...args: any[]) => any> = T extends new (...args: any[]) => infer R ? R : any;
作用：获取一个类的实例类型，可以用获取到的实例类型来约束一个变量的赋值必须和类的成员类型完全一样才可以。
案例：
class Person { name: string age: number getName() { return this.name } } let a: InstanceType<typeof Person> = { name: '李四', age: 34, getName() { return '' } }
13、Omit
源码实现：
type Omit<T, K> = Pick<T, Exclude<keyof T, K>>
作用：用来忽略 T 中的 K 属性
案例：
type Person = { name: string age: number } let a: Omit<Person, 'name'> = { age: 34 } // 正确 let b: Omit<Person, 'name'> = { height: 34 } // 报错，b只包含属性age