Mapped type with conditional types in Typescript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a conditional mapped type

What is the type of Result after this code runs?

Typescript

type Flags = {
  a: string;
  b: number;
  c: boolean;
};

type ConditionalMapped<T> = {
  [K in keyof T]: T[K] extends number ? string : boolean;
};

type Result = ConditionalMapped<Flags>;

A { a: string; b: string; c: boolean; }

B { a: boolean; b: boolean; c: boolean; }

C { a: boolean; b: number; c: boolean; }

D { a: boolean; b: string; c: boolean; }

💡 Hint

Check which properties have type number and what the conditional changes them to.

The mapped type checks each property type. If it extends number, it becomes string; otherwise boolean. So 'b' is number, becomes string; 'a' and 'c' become boolean.

❓ Predict Output

intermediate

Mapped type filtering keys by conditional

What is the type of Filtered after this code runs?

Typescript

type Data = {
  id: number;
  name: string;
  active: boolean;
};

type FilterByType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]: T[K];
};

type Filtered = FilterByType<Data, string>;

A { name: string; }

B { id: number; }

C { id: number; name: string; active: boolean; }

D { active: boolean; }

💡 Hint

Look at the conditional key remapping and which keys match the type string.

The mapped type keeps keys whose value type extends string. Only 'name' is string, so Filtered has only 'name'.

🔧 Debug

advanced

Why does this mapped type cause an error?

This code causes a TypeScript error. What is the cause?

Typescript

type Example<T> = {
  [K in keyof T]: T[K] extends string ? K : never;
};

type Result = Example<{ a: string; b: number; }>;

A The type parameter T is missing a constraint causing error.

B Mapped type values must be types, but here keys are used as values causing error.

C Keys cannot be used in mapped types, only values are allowed.

D The conditional expression is invalid syntax inside mapped types.

💡 Hint

Mapped types define property types, not keys as values.

Mapped types define property types for each key. Returning keys (K) as values is invalid because keys are not types. The value must be a type, not a key name.

❓ Predict Output

advanced

Output type of nested conditional mapped type

What is the type of NestedResult after this code runs?

Typescript

type Nested<T> = {
  [K in keyof T]: T[K] extends number ? string : T[K] extends boolean ? number : T[K];
};

type Input = { x: number; y: boolean; z: string };

type NestedResult = Nested<Input>;

A { x: string; y: boolean; z: string; }

B { x: number; y: number; z: string; }

C { x: string; y: number; z: string; }

D { x: string; y: string; z: string; }

💡 Hint

Check each property type and apply the nested conditional rules carefully.

For 'x' number → string; 'y' boolean → number; 'z' string → string (unchanged).

🧠 Conceptual

expert

How many keys remain after conditional key remapping?

Given this type, how many keys does Final have?

Typescript

type Original = {
  a: string;
  b: number;
  c: boolean;
  d: string | number;
};

type FilterKeys<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K];
};

type Final = FilterKeys<Original>;

A 1

B 2

C 3

D 4

💡 Hint

Check which properties extend string exactly, not unions including string.

Only 'a' is exactly string. 'd' is string | number, which does not extend string alone, so it is excluded. So Final has 1 key.