Summary - Mapped types

Write your own utility type with mapped types.

Summary - Mapped types

Mapped types iterate over a type's properties and transform each one. With [K in keyof T]: T[K] you copy properties; readonly makes them immutable; ? makes them optional. Combining the three you can write your own utility types.

type Guvenli<T> = {
  readonly [K in keyof T]?: T[K];
};

Exercise Your own utility type

Write the mapped type Guvenli<T> as { readonly [K in keyof T]?: T[K] }. Define interface Ayar with tema: string and ses: number. Define type GuvenliAyar as Guvenli<Ayar>. Assign { tema: "koyu" } to a variable a (of type GuvenliAyar). Print a.tema with console.log.

Show example solution

type Guvenli<T> = {
  readonly [K in keyof T]?: T[K];
};
interface Ayar {
  tema: string;
  ses: number;
}
type GuvenliAyar = Guvenli<Ayar>;
const a: GuvenliAyar = { tema: "koyu" };
console.log(a.tema);

Test yourself

You want both immutability and optionality in a mapped type. Which form is correct?
- { [K in keyof T]: T[K]? readonly }
- { [readonly K in keyof T]?: T[K] }
- { [K in keyof T]: readonly T[K] }
- { readonly [K in keyof T]?: T[K] }
Show answer

{ readonly [K in keyof T]?: T[K] } — readonly goes before the square brackets and ? goes right after. This way each property is both immutable and optional. The other forms are syntax errors.

Combined mapped type body

type Guvenli<T> = {
  ____ [K in keyof T]?: T[K];
};

Show answer

type Guvenli<T> = {
  readonly [K in keyof T]?: T[K];
};

Match mapped type transforms

[K in keyof T]: T[K]

Copies all properties as-is
readonly [K in keyof T]: T[K]

Makes all properties immutable
[K in keyof T]?: T[K]

Makes all properties optional
readonly [K in keyof T]?: T[K]

Both immutable and optional

Next lesson: What is a conditional type?

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies