类型工具

Awaited<Type>

Awaited<Type> 用来取出 Promise 的返回值类型。

type A = Awaited<Promise<string>>;  // string
type B = Awaited<Promise<Promise<number>>  // number

如果它的参数类型不是 Promise, 那么就会原样返回。

type C = Awaited<number | Promise<boolean>>;  // number| boolean

ConstructorParameters<Type>

ConstructorParameters<Type> 用于提取构造方法 Type 的参数类型，组成一个元组类型返回。

// [x: string, y: number]
type T1 = ConstructorParameters<new (x: string, y: number) => object>;

// [x?: string, y?: number]
type T2 = ConstructorParameters<new (x?: string, y?: number) => object>;

它可以返回一些内置构造方法的参数类型：

// [message?: string]
type T1 = ConstructorParameters<ErrorConstructor>;

// string[]
type T2 = ConstructorParameters<FunctionConstructor>;

// [pattern: string|RegExp, flags?: string]
type T3 = ConstructorParameters<RegExpConstructor>;

如果参数类型不是构造方法，就会报错。

对于 any 和 never 两个特殊值，分别返回 unknown[] 和 never

type T1 = ConstructorParameters<any>; // unknown[]
type T2 = ConstructorParameters<never>; // never

Exclude<UnionType, ExcludedMembers>

Exclude<UnionType, ExcludedMembers> 用来从联合类型 UnionType 中排除 ExcludedMembers，组成一个新的联合类型返回。

type T1 = Exclude<"a" | "b" | "c", "a">; // 'b'|'c'
type T2 = Exclude<"a" | "b" | "c", "a" | "b">; // 'c'
type T3 = Exclude<string | (() => void), Function>; // string
type T4 = Exclude<string | string[], any[]>; // string
type T5 = Exclude<(() => void) | null, Function>; // null
type T6 = Exclude<200 | 400, 200 | 201>; // 400
type T7 = Exclude<number, boolean>; // number

Extract<Type, Union>

Extract<Type, Union> 用来从联合类型 Union 中提取 Type，组成一个新的联合类型返回。

type T1 = Extract<"a" | "b" | "c", "a">; // 'a'
type T2 = Extract<"a" | "b" | "c", "a" | "b">; // 'a'|'b'
type T3 = Extract<"a" | "b" | "c", "a" | "d">; // 'a'
type T4 = Extract<string | string[], any[]>; // string[]
type T5 = Extract<(() => void) | null, Function>; // () => void
type T6 = Extract<200 | 400, 200 | 201>; // 200

如果参数类型 Union 不包含在联合类型 UnionType 中，则返回 never 类型。

type T1 = Extract<"a" | "b" | "c", "d">; // never

Instancetype<Type>

Instancetype<Type> 提取构造函数的返回值类型（即实例类型），参数 Type 是一个构造函数，等同于构造函数 ReturnType<Type>

type T = InstanceType<new () => object>; // object

class C {
    x = 0;
    y = 0;
}

type T = InstanceType<typeof C>; // C

在上面示例中， typeof C 是 C 的构造方法类型，然后 InstanceType 就能获得到 C 的实例类型。

如果类型参数不是构造方法，就会报错。

如果类型参数是any或 never 两个特殊值，分别返回 any 和 never。

type T1 = InstanceType<any>; // any

type T2 = InstanceType<never>; // never

NonNullable<Type>

NonNullable<Type> 用来从联合类型 Type 中排除 null 和 undefined，组成一个新的类型返回。也就是说返回 Type 的非空类型版本。

type T1 = NonNullable<string | number | undefined>; // string|number
type T2 = NonNullable<string[] | null | undefined>; // string[]
type T3 = NonNullable<boolean>; // boolean
type T4 = NonNullable<number | null>; // number
type T5 = NonNullable<string | undefined>; // string
type T6 = NonNullable<null | undefined>; // never

Omit<Type, Keys>

Omit<Type, Keys> 用来从类型 Type 中排除 Keys，组成一个新的类型返回。

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

type T1 = Omit<A, "x">; // { y: number }
type T2 = Omit<A, "y">; // { x: number }
type T3 = Omit<A, "x" | "y">; // { }

OmitThisParameter<Type>

OmitThisParameter<Type> 用来从函数类型 Type 中排除 this 参数，组成一个新的类型返回。

function toHex(this: Number) {
  return this.toString(16);
}

type T1 = OmitThisParameter<typeof toHex>;  // () => string

如果函数没有 this 参数，则返回原始函数类型。

Parameters<Type>

Parameters<Type> 提取构造函数 Type 的参数类型，组成一个元组类型返回。

// [x: string, y: number]
type T1 = Parameters<new (x: string, y: number) => object>;

// []
type T2 = Parameters<() => object>;

// [x?: string, y?: number]
type T3 = Parameters<(x?: string, y?: number) => object>;

// [x: { a: string }, y: { b: number }]
type T4 = Parameters<(x: { a: string }, y: { b: number }) => object>;

对于 any 和 never 两个特殊值，分别返回 unknown[] 和 never。

type T1 = Parameters<any>; // unknown[]
type T2 = Parameters<never>; // never

Partial<Type>

Partial<Type> 用来将类型 Type 中的所有属性变成可选，组成一个新的类型返回。

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

type T1 = Partial<A>; // { x?: number, y?: number }`

Pick<Type, Keys>

Pick<Type, Keys> 用来从类型 Type 中提取 Keys，组成一个新的类型返回。

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

type T1 = Pick<A, "x">; // { x: number }
type T2 = Pick<A, "y">; // { y: number }
type T3 = Pick<A, "x" | "y">; // { x: number, y: number }

指定的键名 Keys 必须是对象键名 Type 里面已经存在的键名，否则会报错。

Readonly<Type>

Readonly<Type> 用来将类型 Type 中的所有属性变成只读，组成一个新的类型返回。

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

type T1 = Readonly<A>; // { readonly x: number, readonly y?: number }

我们可以自定义类型工具Mutable<Type>，将参数类型的所有属性变成可变属性。

type Mutable<T> = {
    -readonly [P in keyof T]: T[P]
}

Record<Keys, Type>

Record<Keys, Type> 用来创建一个类型为 Type，键名为 Keys 的对象，组成一个新的类型返回。

type T1 = Record<"x" | "y", number>; // { x: number, y: number }
type T2 = Record<"x" | "y", string>; // { x: string, y: string }
type T3 = Record<string, number>; // { [key: string]: number }
type T4 = Record<'a', number|string>; // { a: number|string }

参数Keys的类型必须兼容string|number|symbol，否则不能用作键名，会报错。

Required<Type>

Required<Type> 用来将类型 Type 中的所有属性变成必选，组成一个新的类型返回。

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

type T1 = Required<A>; // { x: number, y: number }

Required<Type> 的实现如下：

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

在上面代码中，符号 -? 表示去除可选属性的"问号"，使其变成可选属性。相对应的，符号 +? 表示增加可选属性的"问号"，使其变成必选属性。

因此，前面的 Partial<Type> 的定义也可以写成下面这样。

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

ReadonlyArray<Type>

ReadonlyArray<Type> 用来生成一个只读数组类型，类型参数 Type 表示数组成员类型。

const values: ReadonlyArray<string> = ["a", "b", "c"];

values[0] = "x"; // 报错
values.push("x"); // 报错
values.pop(); // 报错
values.splice(1, 1); // 报错

ReturnType<Type>

ReturnType<Type> 提取函数类型 Type 的返回值类型，作为一个新类型返回。

type T1 = ReturnType<() => string>; // string

type T2 = ReturnType<() => { a: string; b: number }>; // { a: string; b: number }

type T3 = ReturnType<(s: string) => void>; // void

type T4 = ReturnType<() => () => any[]>; // () => any[]

type T5 = ReturnType<typeof Math.random>; // number

type T6 = ReturnType<typeof Array.isArray>; // boolean

如果参数类型是泛型函数，返回值取决于泛型类型。如果泛型不带限制条件，就会返回 unknown。

type T1 = ReturnType<<T>() => T>; // unknown

type T2 = ReturnType<<T extends U, U extends number[]>() => T>; // number[]

any 和 never 两个特殊值分别返回 any 和 never

ThisParameterType<Type>

ThisParameterType<Type> 提取函数类型中 this 参数的类型。

function toHex(this: number) {
    return this.toString(16);
}

type T = ThisParameterType<typeof toHex>; // number

如果函数没有 this 参数，则返回 unknown。

ThisType<Type>

ThisType<Type> 不返回类型，只用来跟其他类型组成交叉类型，用来提示 TypeScript 其他类型里面的 this 类型。

interface HelperThisValue {
    logError: (error: string) => void;
}

let helperFunctions: { [name: string]: Function } & ThisType<HelperThisValue> = {
    hello: function () {
        this.logError("Error: Something wrong!"); // 正确
        this.update(); // 报错
    },
};

在上面的示例中，变量 helperFunctions 的类型是一个正常的对象类型与 ThisType 类型组成的交叉类型。

注意：使用这个类型工具时，必须打开 noImplicitThis 设置。

字符串类型工具

Uppercase<StringType>

Uppercase<StringType> 将字符串类型的每个字符转为大写。

type A = "hello";

// "HELLO"
type B = Uppercase<A>;

Lowercase<StringType>

Lowercase<StringType> 将字符串的每个字符转为小写。

type A = "HELLO";

// "hello"
type B = Lowercase<A>;

Capitalize<StringType>

Capitalize<StringType> 将字符串的第一个字符转为大写。

type A = "hello";

// "Hello"
type B = Capitalize<A>;

Uncapitalize<StringType>

Uncapitalize<StringType> 将字符串的第一个字符转为小写。

type A = "HELLO";

// "hELLO"
type B = Uncapitalize<A>;