typescript：内置工具类型

Typescript提供了一些比较使用的工具类型，这些类型都返回一种新的类型，这种新的类型都是对提供的类型进行一些操作而生成。根据工具类型返回的类型的不同，我们把它们分为对象类型、非对象类型。

对象类型

这一主题下的工具类型的运算结果都是返回对象类型

Partial

将实际类型参数 T 中的所有属性变为可选属性。Partial返回的是一个对象类型。

interface Info{
name:string
age:number
}
let name: Partial<Info>
1
2
3
4
5

上例中的name相当于下面的写法：

type PartialInfo = {
	name?:string,
	age?:number
}
1
2
3
4

Required

将实际类型参数T中的所有属性变为必选属性，Required返回的是一个对象类型。

interface Info{
name?:string
age?:number
}
let p: Required<Info>
1
2
3
4
5

上面的例子中的p的类型相当于下面的写法：

type RequiredResult = {
	name:string,
	age:number
}
1
2
3
4

如果在赋值时其中的任意一个属性不写会报错。

Pick

从已有对象类型中选取给定的属性及其类型，然后构建一个新的对象类型

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

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

type T3: Pick<A, 'z'>;
// ~~~
// 编译错误：类型'A'中不存在属性'z'
1
2
3
4
5
6
7
8
9
10
11
12

Record

Record 能够使用给定的对象属性名类型和对象属性类型创建一个新的对象类型。

Record<T,U>
1

类型参数T提供了对象属性名联合类型，类型参数U提供了对象属性的类型

type T = 'age' | 'weight'
type U = number
type R = Record<Info, Addre>
1
2
3

Readonly

将实际类型参数T中的所有属性变为只读属性

interface Info{
name:string
age:number
}
let p: Readonly<Info>
1
2
3
4
5

上例中的p的类型相当于下面的写法：

type ReadonlyResult = {
	readonly name:string,
	readonly age:number
}
1
2
3
4

Omit

能够从已有对象类型中剔除给定的属性

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

非对象类型

这一主题下的工具类型的运算结果返回的是非对象类型，可以是联合类型也可以是单一的类型

Exclude

从类型T中剔除所有可以赋值给类型U的类型，可以是联合类型也可以是单一的类型，具体视传入的类型决定。

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

Extract

从类型T中获取所有可以赋值给类型U的类型，与Exclude是互补关系

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

NoneNullable

从类型T中剔除null类型和undefined类型并构造一个新类型，也就是获取类型T中的非空类型

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

// string[]
type T1 = NonNullable<string[] | null | undefined>;
1
2
3
4
5

Parameters

获取函数类型T的参数类型并使用参数类型构造一个元组类型

type T0 = Parameters<() => string>;        // []
type T1 = Parameters<(s: string) => void>; // [string]

type T2 = Parameters<<T>(arg: T) => T>;    // [unknown]

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

type T5 = Parameters<any>;                 // unknown[]

type T6 = Parameters<never>;               // never

type T7 = Parameters<string>;
 //                   ~~~~~~~
//                   编译错误！string类型不符合约束'(...args: any) => any'

type T8 = Parameters<Function>;
//                   ~~~~~~~~
//                   编译错误！Function类型不符合约束'(...args: any) => any'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

CustomerParameters

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

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

// [(string | undefined)?]
type T1 = ConstructorParameters<new (x?: string) => object>;
 
type T2 = ConstructorParameters<string>;   // 编译错误
type T3 = ConstructorParameters<Function>; // 编译错误
1
2
3
4
5
6
7
8

ReturnType

获取函数类型T的返回值类型

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

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

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

// {}
type T3 = ReturnType<<T>() => T>;

// number[]
type T4 = ReturnType<<T extends U, U extends number[]>() => T>;
 
// any
type T5 = ReturnType<never>;

type T6 = ReturnType<boolean>;   // 编译错误
type T7 = ReturnType<Function>;  // 编译错误
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

InstanceType

获取构造函数的返回值类型，即实例类型

class C {
     x = 0;
 }
type T0 = InstanceType<typeof C>;         // C

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

type T2 = InstanceType<any>;              // any

type T3 = InstanceType<never>;            // any

type T4 = InstanceType<string>;           // 编译错误
type T5 = InstanceType<Function>;         // 编译错误
1
2
3
4
5
6
7
8
9
10
11
12
13

ThisParameterType

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

/**
 * --strictFunctionTypes=true
*/
 
function f0(this: object, x: number) {}
function f1(x: number) {}

type T0 = ThisParameterType<typeof f0>;  // object
type T1 = ThisParameterType<typeof f1>;  // unknown
type T2 = ThisParameterType<string>;     // unknown
1
2
3
4
5
6
7
8
9
10

OmitThisParameter

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

在使用“Omit-ThisParameter”工具类型时需要启用“–strictFunctionTypes”编译选项

/**
 * --strictFunctionTypes=true
*/

function f0(this: object, x: number) {}
function f1(x: number) {}

// (x: number) => void
type T0 = OmitThisParameter<typeof f0>;

// (x: number) => void
type T1 = OmitThisParameter<typeof f1>;

// string
type T2 = OmitThisParameter<string>;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

ThisType

用于定义对象字面量的方法中this的类型

如果对象字面量的类型是“ThisType”类型或包含“ThisType”类型的交叉类型，那么在对象字面量的方法中this的类型为T。在使用“ThisType”工具类型时需要启用“–noImplicitThis”编译选项

/**
* --noImplicitThis=true
*/

let obj: ThisType<{ x: number }> & { getX: () => number };

obj = {
    getX() {
         this; // { x: number; y: number; }

        return this.x;
    },
};
1
2
3
4
5
6
7
8
9
10
11
12
13