Typescript中的高级类型工具

一、Partial

源码：

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

该工具类型可以构造一个新的类型，并把实际类型参数 T 中的属性全变成可选属性

  interface A {
    x: number;
    y: number;
  }
  type T = Partial<A>; // {x?number; y?:number}}
1
2
3
4
5

二、 Required

源码：

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

和 Partial 相反， 把T 中的属性全变成必选属性

  interface A {
    x?: number;
    y: number;
  }

  type T = Required<A>; // {x:number; y:number}}
1
2
3
4
5
6

三、 Readonly

源码：

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

该工具类型可以构造一个新的类型， 并将类型参数 T 中的所有属性变成只读属性

  interface A {
    x: number;
    y: number;
  }

  type T = Readonly<A>; // {x:number; y:number}}
  const a: T = { x: 0, y: 0 }
  // a.x = 1  无法分配到 "x" ，因为它是只读属性
  // a.y = 1  无法分配到 "y" ，因为它是只读属性
1
2
3
4
5
6
7
8
9

四、 Record

源码：

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

该工具类型可以使用给定的 对象属性名类型 和 对象属性类型，创建一个新的对象类型

  type K = 'x' | 'y';
  type T = number;
  type R = Record<K, T>; // {x:number; y:number}} 
  const a: R = { x: 0, y: 0 }
1
2
3
4

五、Exclude

源码：

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

该工具类型可以从类型 T 中剔除所有可以赋值给类型 U 的类型

  type T0 = Exclude<"a" | "b", 'x'>; // "a" | "b"
  type T1 = Exclude<string | (() => void), Function>; // string
1
2

六、 Extract

源码：

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

该工具类型和 Exclude类型互补， 它能从类型 T 中获取所有可以赋值给类型 U 的类型

  type T0 = Extract<"a" | "b", 'a'>;  // "a"
  type T1 = Extract<string | (() => void), Function>; // () => void
  type T2 = Extract<"a" | "b", 'c'>;  // never
1
2
3

七、 Pick

源码：

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

该工具能出已有对象类型中选取给定的属性以及其类型，然后构建一个新的对象类型

  interface A {
    x: number;
    y: number;
  }
  type T0 = Pick<A, 'x'>; // {x:number}
  type T1 = Pick<A, 'x' | 'y'>; // {x:number; y:number}

  // type T3 = Pick 类型“"z"”不满足约束“keyof A”
1
2
3
4
5
6
7
8

八、 Omit

源码：

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

该工具与 Pick 类型互补，能从已有对象类型中剔除给定的属性，然后构建一个新的对象类型

  interface A {
    x: number;
    y: number;
  }

  type T0 = Omit<A, 'x'>; // {y:number}
  type T1 = Omit<A, 'x' | 'y'>; // {}
  type T3 = Omit<A, 'z'>; // {}
1
2
3
4
5
6
7
8

九、 NonNullable

源码：

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

该工具类型能从类型 T 中剔除 null 和 undefined 类型，并构建一个新的类型

type T0 = NonNullable<string | number | null | undefined>; // string | number
1

十、 Parameters

源码：

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

该工具类型能获取函数类型 T 的参数类型，并使用参数类型构建一个元组类型

  type T0 = Parameters<() => void>; // []
  type T1 = Parameters<(a: string) => void>; // [string]
  type T2 = Parameters<(a: string, b: number) => void>; // [string, number]
  type T3 = Parameters<(x: { a: number, b: string }) => void>; // [{ a: number; b: string }]
1
2
3
4

十一、 ConstructorParameters

源码：

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

该工具类型能获取构造函数 T 中的参数类型， 并使用参数类型构造一个元组类型。 若 T 不是函数类型，则`返回 never 类型

type T0 = ConstructorParameters<new (s?: string) => object>; //  [s?: string | undefined]
1

十二、 ReturnType

源码：

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
1

该工具类型能获取函数类型 T 的返回值类型

  type T0 = ReturnType<() => string>; // string
  type T1 = ReturnType<() => { a: string, b: number }>; // { a: string; b: number }
1
2

十三、 InstanceType

源码：

type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;
1

该工具类型能获取构造函数的返回值类型

  class A {
    x = 0;
  }

  type T0 = InstanceType<typeof A>; // A
  type T1 = InstanceType<new (s?: string) => object>; // object
1
2
3
4
5
6

十四、 ThisParameterType

源码：

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

该工具类型能获取函数类型 T 中的 this 参数类型，若函数类型定义中没有 this 参数，则返回 unknown 类型

  function fn(this: object, x: number) { }
  function fn1(x: number) { }

  type T0 = ThisParameterType<typeof fn> // object
  type T1 = ThisParameterType<typeof fn1> // unknown
1
2
3
4
5

十五、 OmitThisParameter

源码：

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

该工具类型能从类型 T 中剔除 this 参数类型，并构造一个新类型

  function fn(this: object, x: number) { }

  type T0 = OmitThisParameter<typeof fn> // (x: number) => void
1
2
3

🎂