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
     
       = {    [P in keyof T]?: T[P];};/** * Make all properties in T readonly */type Readonly
      
        = {    readonly [P in keyof T]: T[P];};/** * From T pick a set of properties K */type Pick
       
         = {    [P in K]: T[P];};/** * Construct a type with a set of properties K of type T */type Record
        
          = {    [P in K]: T;};
        
       
      
     

 

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

interface Point {

   x: number;

   y: number;

}

ReadonlyPoint = Readonly
     
      ; 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;}// Fromtype 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"];}// Totype ReadonlyPoint = {    readonly x: number    readonly y: number;}

 

The same process can be done with Partial type:

type PartialPoint = Partial
     
      ;// Fromtype 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"];}// Totype PartialPoint = {    x?: number;    y?: number;}
     

 

We can also write Nullable type by ourselves:

type Nullable
     
       = {   [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
     
       = {    [P in keyof T]: T[P] | null}type Stringify
      
        = {    [P in keyof T]: string}type NullablePoint = Nullable
       
        type PartialNullablePoint = Partial
        
         
          
           >>