Optional mapped type

Learn to make properties optional with a mapped type.

Optional mapped type

With a mapped type you can make all of T's properties optional. Writing { [K in keyof T]?: T[K] } marks each property with ?; a missing value can be undefined. This is the basis of the Partial utility type.

type Kismi<T> = {
  [K in keyof T]?: T[K];
};
interface Uye { ad: string; yas: number; }
const u: Kismi<Uye> = { ad: "Can" };
// yas can be omitted

Partial data flow

An optional mapped type is especially handy for updates or partial data flows. When only some fields arrive from an API, you use Kismi<T> instead of a type requiring all. The body skips missing fields with an undefined check; type safety is preserved.

Exercise Partial member

Write the mapped type Kismi<T> as { [K in keyof T]?: T[K] }. Define interface Uye with ad: string and yas: number. Define type KismiUye as Kismi<Uye>. Assign { ad: "Can" } to a variable u (of type KismiUye). Print u.ad with console.log.

Show example solution

type Kismi<T> = {
  [K in keyof T]?: T[K];
};
interface Uye {
  ad: string;
  yas: number;
}
type KismiUye = Kismi<Uye>;
const u: KismiUye = { ad: "Can" };
console.log(u.ad);

Test yourself

Which object is valid as the result of the mapped type below?
```
type Kismi<T> = { [K in keyof T]?: T[K]; };
interface Uye { ad: string; yas: number; }
```
- Any subset, including the empty object
- Only an object with the ad property
- An object whose properties are all numbers
- Only an object containing every property
Show answer

Any subset, including the empty object — Because ? makes all properties optional, any subset (including the empty object) is valid. The types do not change; only the requirement is lifted.

Add the ? mark

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

Show answer

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

Optional mapped type parts

[K in keyof T]?

Makes all properties optional
T[K]

Keeps the value type the same
{ ad: "Can" }

Valid object with a missing field
type Kismi<T>

Optional mapped type alias

Next lesson: Summary - Mapped types

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies