[TypeScript] Transform Existing Types Using Mapped Types in TypeScript

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

Mapped types are a powerful and unique feature of TypeScript's type system. They allow you to create a new type by transforming all properties of an existing type according to a given transformation function. In this lesson, we'll cover mapped types like Readonly<T> or Partial<T> that ship with the TypeScript compiler, and we'll also explore how to create our own type transformations.

There are few mapped types built-in:

/**
* Make all properties in T optional
*/
type Partial<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 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 string, T> = {
[P in K]: T;
};

Take readonly as an example, the output is like this:

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

ReadonlyPoint = Readonly<Point>;type ReadonlyPoint = {
readonly x: number;
readonly y: number;
}

So for each props in Point, we append 'readonly' type for it.

The way type resolve:

interface Point {
x: number;
y: number;
}// From
type ReadonlyPoint = {
readonly [P in keyof Point]: Point[P]
}type ReadonlyPoint = {
readonly [P in "x" | "y"]: Point[P]
}type ReadonlyPoint = {
readonly x: Point["x"];
readonly y: Point["y"];
}// To
type ReadonlyPoint = {
readonly x: number
readonly y: number;
}

The same process can be done with Partial type:

type PartialPoint = Partial<Point>;// From
type PartialPoint = {
[P in keyof T]?: T[P];
}type PartialPoint = {
[P in keyof Point]?: Point[P];
}type PartialPoint = {
[P in "x" | "y"]?: Point[P];
}type PartialPoint = {
x?: Point["x"];
y?: Point["y"];
}// To
type PartialPoint = {
x?: number;
y?: number;
}

We can also write Nullable type by ourselves:

type Nullable<T> = {
[P in keyof T]: T[P] | null
}

For each Prop fo Type T, it can be its value or null.

We can also combine different type together:

type Nullable<T> = {
[P in keyof T]: T[P] | null
}type Stringify<T> = {
[P in keyof T]: string
}type NullablePoint = Nullable<Point>
type PartialNullablePoint = Partial<Nullable<Stringify<Point>>>