Typescript 中的高级类型

源码定义

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;

/**
 * Marker for contextual 'this' type
 */
interface ThisType<T> {
      }

Record
以 typeof 格式快速创建一个类型，此类型包含一组指定的属性且都是必填。

type Coord = Record<'x' | 'y', number>;

// 等同于
type Coord = {
     
	x: number;
	y: number;
}

具体的复杂业务场景中，一般会接口 Pick 、Partial 等组合使用，从而过滤和重组出新的类型定义。

Partial
将类型定义的所有属性都修改为可选。

type Coord = {
     
	x: number;
	y: number;
}

type Coords = Partial<Coord>;

// 等同于
type Coords = {
     
	x?: number;
	y?: number;
}

Required
与 Partial程序类型的作用相反，将类型属性都变成必填。

type Coord = {
     
	x?: number;
	y?: number;
}
type Coords = Required<Coord>;

// 等同于
type Coords = {
     
	x: number;
	y: number;
}

Readonly
不管是从字面意思，还是定义上都很好理解：将所有属性定义为自读。

type Coord = {
     
	x: number;
	y: number;
}

type Coords = Readonly<Coord>;

// 等同于
type Coords = {
     
    readonly x: number;
    readonly x: number;
}

Pick
从类型定义的属性中，选取指定一组属性，返回一个新的类型定义。

type Coord = Record<'x' | 'y', number>;
type Coords = Pick<Coord, 'x'>;

// 等用于
type Coords = {
     
	x: number;
}

Exclude
排除一个 联合类型 中指定的子类型

type T = Exclude<'x' | 'y', 'x'> // 'y'

主要是基于 extends 条件类型的解析推迟的特性，返回了匹配之外的所有 候选类型，配合 never 类型 的空值特性，实现了这一高级类型。

Extract
与 Exclude 完全相反的功能，用于提取指定的 联合类型，如果不存在提取类型，则返回never。可以用在判断一个复杂的 联合类型 中是否包含指定子类型：

type T = Extract<'x' | 'y', 'x'> // 'x'

Omit
排除接口中指定的属性：

type Coord = {
     
	x: number;
	y: number;
}

type Coords = Omit<Coord, 'x'>;     // { y:number} 

NonNullable
过滤掉 联合类型 中的 null 和 undefined 类型：

type T1= NonNullable<string | null | undefined>; // string

额外说明下，因为 null 和 undefined 类型的特殊性，他们可以赋值给任何类型，这往往会带来意料之外的错误。当你开启 --strictNullChecks 设置后，TS 就会严格检查，只有被声明 null 后才能被赋值：

Parameters
获取函数的全部参数类型，以 元组类型 返回：

type F1 = (a: string, b: number) => void;

type F1ParamTypes = Parameters(F1);  // [string, number]

ConstructorParameters
同上面的类型很相似，只是这里获取的是 构造函数 的全部参数。关于构造函数声明，以及如何使用此 高级类型 的方式：

interface IEntity {
     
    count?: () => number
}

interface IEntityConstructor {
     
    new (a: boolean, b: string): IEntity;
}

class Entity implements IEntity {
     
    constructor(a: boolean, b: string) {
      }
}

type EntityConstructorParamType = ConstructorParameters<IEntityConstructor>; // [boolean, string]


function createEntity(ctor: IEntityConstructor, ...arg: EntityConstructorParamType): IEntity {
     
    return new ctor(...arg);
}

const entity = createEntity(Entity, true, 'a');

InstanceType
获取 构造函数 的返回类型，如果是多个就以 联合类型 的方式返回，我们借用上面的定义：

type EntityType = InstanceType<IEntityConstructor>; // IEntity

ReturnType
返回函数的返回值类型，如果多个类型则以 联合类型 方式返回：

type F1 = () => Date;

type F1ReturnType = ReturnType<F1>; // Date

ThisParameterType
获取函数中 this 的数据类型，如果没有则返回 unknown 类型：

interface Foo {
     
    x: number
};

function fn(this: Foo) {
     }

type Test = ThisParameterType<typeof fn>; // Foo

因为可以在 TS 声明函数的 this ，此方法用于获取此声明，具体的使用：

fn.bind({
      x: 1 });   // 正常

fn.bind({
      x: '1' }); // Error: ...Type 'string' is not assignable to type 'number'...

OmitThisParameter
移除函数中的 this 数据类型：

interface Foo {
     
    x: number
};

type Fn = (this: Foo) => void

type NonReturnFn = OmitThisParameter<Fn>; // () => void
声明此类的函数类型效果如下：

function f(this: void) {
     } // 此声明在函数内不可使用 this