上面的 Pick 和 Exclude 都是最基础的工具类型，很多时候用 Pick 或者 Exclude 可能不如直接写类型更直接。而 Omit 就基于这两个来做的一个更抽象的封装，它允许从一个对象中剔除若干个属性，剩下的就是需要的新类型。下面是它的声明形式：

/** * Construct a type with the properties of T except for those in type K. */type Omit = Pick>;

来看下面的例子：

type Person = {  name: string;  age: number;  height: number;}const person: Omit = {  name: "zhangsan";}

这样就使用Omit从Person类型中剔除了 age 和 height 属性，只剩下 name 属性。

ReturnType会返回函数返回值的类型，其声明形式如下：

/** * Obtain the return type of a function type */type ReturnType any> = T extends (...args: any) => infer R ? R : any;

来看下面的例子：

function foo(type): boolean {  return type === 0}type FooType = ReturnType

这里使用 typeof 是为了获取 foo 的函数签名，等价于 (type: any) => boolean。

InstanceType 会返回 Type 构造函数类型的实例类型。其声明形式如下：

/** * Obtain the return type of a constructor function type */type InstanceType any> = T extends abstract new (...args: any) => infer R ? R : any;

来看下面的例子：

class Person {  name: string;  age: number;  constructor(person: { name: string; age: number }) {    this.name = person.name;    this.age = person.age;  }}type PersonInstanceType = InstanceType;// PersonInstanceType 的类型：{ name: string; age: number }

当然，你可能不会这么写，因为可以直接使用UserManager类型：

class Person {  name: string;  age: number;  constructor(person: { name: string; age: number }) {    this.name = person.name;    this.age = person.age;  }}const person: Person = {  name: "zhangsan",  age: 18,};

这就等价于：

class Person {  name: string;  age: number;  constructor(person: { name: string; age: number }) {    this.name = person.name;    this.age = person.age;  }}type PersonInstanceType = InstanceType;                                       const person: PersonInstanceType = {  name: "zhangsan",  age: 18,};

当我们在 TypeScript 中创建动态类时，InstanceType可以用于检索动态实例的类型。

Parameters 可以从函数类型Type的参数中使用的类型构造一个元组类型。其声明形式如下：

/** * Obtain the parameters of a function type in a tuple */type Parameters any> = T extends (...args: infer P) => any ? P : never;

来看下面的例子：

const add = (x: number, y: number) => {  return x + y;};type FunctionParameters = Parameters;// FunctionParameters 的类型：[x: number, y: number]

除此之外，还可以检测单个参数：

// "number"type FirstParam = Parameters[0];// "number"type SecondParam = Parameters[1];// "undefined"type ThirdParam = Parameters[2];

Parameters 对于获取函数参数的类型以确保类型安全很有用，尤其是在使用第三方库时：

const saveUser = (user: { name: string; height: number; age: number }) => {  // ...};const user: Parameters[0] = {  name: "zhangsan",  height: 180,  age: 18,};

ConstructorParameters 可以从构造函数的类型来构造元组或数组类型。其声明形式如下：

/** * Obtain the parameters of a constructor function type in a tuple */type ConstructorParameters any> = T extends abstract new (...args: infer P) => any ? P : never;

它类似于参数，但适用于类构造函数：

class Person {  private name: string;  private age: number;  constructor(person: { name: string; age: number }) {    this.name = person.name;    this.age = person.age;  }}type ConstructorParametersType = ConstructorParameters;// ConstructorParametersType 的类型：[person: { name: string, age: number}]

与 Parameters 类型一样，当使用外部库时，它有助于确保构造函数接受我们传入的参数：

class Person {  private name: string;  private age: number;  constructor(person: { name: string; age: number }) {    this.name = person.name;    this.age = person.age;  }}const params: ConstructorParameters[0] = {  name: "zhangsan",  age: 18,};

NonNullable 通过从Type中排除null和undefined来创建新类型。它就等价于Exclude。其声明形式如下：

/** * Exclude null and undefined from T */type NonNullable = T extends null | undefined ? never : T;

来看下面的例子：

type Type = string | null | undefined; // stringtype NonNullableType = NonNullable;

这里就使用NonNullable将Type中的null和undefined剔除掉了。

关键词： 所有属性 构造函数 枚举类型