Mapped type with conditional types in Typescript - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a mapped type that makes all properties optional.

Typescript

type PartialType<T> = { [P in keyof T]?: T[1] };

Drag options to blanks, or click blank then click option'

A[P]

Attempts:

3 left

💡 Hint

Common Mistakes

Using T.P instead of T[P]

Forgetting the optional modifier '?'

In a mapped type, [P in keyof T] iterates over keys of T. The syntax T[P] accesses the type of property P in T.

2fill in blank

medium

Complete the code to create a mapped type that makes properties readonly only if they are strings.

Typescript

type ReadonlyStrings<T> = { [P in keyof T]: T[P] extends string ? [1] : T[P] };

Drag options to blanks, or click blank then click option'

AT[P]

Breadonly T[P]

Creadonly P

Dreadonly string

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'readonly P' instead of 'readonly T[P]'

Forgetting to use 'readonly' keyword

The conditional type checks if T[P] extends string, then makes that property readonly by prefixing with 'readonly'.

3fill in blank

hard

Fix the error in the mapped type that should exclude properties of type number.

Typescript

type ExcludeNumbers<T> = { [P in keyof T as T[P] extends number ? never : [1]]: T[P] };

Drag options to blanks, or click blank then click option'

Astring

Bnever

Ckeyof T

DP

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'never' instead of 'P' in the else part

Using 'keyof T' which is invalid here

The 'as' clause remaps keys. To keep keys that are not numbers, use 'P' for those keys.

4fill in blank

hard

Fill both blanks to create a mapped type that makes properties nullable only if they are objects.

Typescript

type NullableObjects<T> = { [P in keyof T]: T[P] extends object ? [1] : [2] };

Drag options to blanks, or click blank then click option'

AT[P] | null

BT[P]

Cnull

Dundefined

Attempts:

3 left

💡 Hint

Common Mistakes

Making all properties nullable regardless of type

Using 'null' alone instead of 'T[P] | null'

If T[P] is an object, we add '| null' to make it nullable; otherwise, keep the original type.

5fill in blank

hard

Fill both blanks to create a mapped type that picks only properties whose types extend string or number.

Typescript

type PickStringOrNumber<T> = { [P in keyof T as T[P] extends [1] ? P : T[P] extends [2] ? P : never]: T[P] };

Drag options to blanks, or click blank then click option'

Astring

Bnumber

Dboolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'boolean' instead of 'number'

Adding extra modifiers to property types

The mapped type uses conditional keys to pick properties of type string or number. The third blank is empty because no modification is needed to the property type.

Practice

1. What does a mapped type with conditional types do in TypeScript?
type Example<T> = { [K in keyof T]: T[K] extends string ? number : boolean }

easy

A. It creates a new type where string properties become number and others become boolean.

B. It creates a new type with all properties removed.

C. It changes all properties to string type.

D. It only keeps properties that are strings.

Solution

1. Step 1: Understand mapped types

   Mapped types loop over each key in the original type to create a new type with transformed properties.

2. Step 2: Apply conditional types

   The conditional type checks if the property type extends string; if yes, it changes to number, else to boolean.

3. Final Answer:

   It creates a new type where string properties become number and others become boolean. -> Option A

4. Quick Check:

   Mapped + conditional changes types based on condition [OK]

Hint: Mapped types loop keys; conditional types pick types by condition [OK]

Common Mistakes:

• Thinking it removes properties instead of transforming them
• Assuming all types become string
• Confusing conditional type logic

2. Which of the following is the correct syntax for a mapped type with a conditional type in TypeScript?

easy

A. type NewType<T> = { [K in T]: T[K] extends number ? string : boolean }

B. type NewType<T> = { [K in keyof T]: T[K] extends number ? string : boolean }

C. type NewType<T> = { [K of keyof T]: T[K] extends number ? string : boolean }

D. type NewType<T> = { K in keyof T: T[K] ? string : boolean }

Solution

1. Step 1: Check mapped type syntax

   The correct syntax uses square brackets with 'in' keyword: [K in keyof T].

2. Step 2: Verify conditional type usage

   The conditional type is written as T[K] extends number ? string : boolean, which is correct.

3. Final Answer:

   type NewType<T> = { [K in keyof T]: T[K] extends number ? string : boolean } -> Option B

4. Quick Check:

   Mapped type syntax = [K in keyof T] [OK]

Hint: Mapped types use [K in keyof T], not 'of' or missing brackets [OK]

Common Mistakes:

• Using 'K in T' instead of 'K in keyof T'
• Using 'K of keyof T' which is invalid
• Missing square brackets around K in mapped type

3. Given the code:

type Flags = { a: string; b: number; c: boolean };
type Result = { [K in keyof Flags]: Flags[K] extends number ? 'num' : 'not-num' };
const test: Result = { a: 'not-num', b: 'num', c: 'not-num' };

What is the type of test.b?

medium

A. 'not-num'

B. number

C. 'num'

D. boolean

Solution

1. Step 1: Analyze the mapped type Result

   For each key in Flags, if the property type is number, Result's property is 'num', else 'not-num'.

2. Step 2: Check property b in Flags

   b is number, so Result['b'] is 'num'.

3. Final Answer:

   'num' -> Option C

4. Quick Check:

   Flags['b'] is number, so Result['b'] = 'num' [OK]

Hint: Check original type, then apply conditional mapping [OK]

Common Mistakes:

• Confusing original property type with mapped type
• Assuming test.b is number instead of 'num'
• Ignoring conditional type logic

4. Identify the error in this mapped type:

type Fix<T> = { [P in keyof T]: T[P] extends string ? number : }

medium

A. Incorrect use of keyof operator

B. Cannot use conditional types inside mapped types

C. Square brackets missing around P

D. Missing type after colon in conditional type

Solution

1. Step 1: Check conditional type syntax

   Conditional types require both true and false branches separated by colon.

2. Step 2: Identify missing false branch

   The code ends with ':' but no type after it, causing syntax error.

3. Final Answer:

   Missing type after colon in conditional type -> Option D

4. Quick Check:

   Conditional types need both branches [OK]

Hint: Conditional types need both true and false parts [OK]

Common Mistakes:

• Leaving out false branch in conditional type
• Misplacing square brackets in mapped type
• Thinking keyof is wrong here

5. How can you create a mapped type that keeps only the keys of an object whose values are assignable to a specific type, for example, only keys with string values?
Choose the correct mapped type:

hard

A. type FilterStrings<T> = { [K in keyof T as T[K] extends string ? K : never]: T[K] }

B. type FilterStrings<T> = { [K in keyof T]: T[K] extends string ? never : K }

C. type FilterStrings<T> = { [K in keyof T]: T[K] extends string ? string : never }

D. type FilterStrings<T> = { [K in keyof T]: K extends string ? T[K] : never }

Solution

1. Step 1: Understand key remapping in mapped types

   Using 'as' allows filtering keys by condition, replacing keys with 'never' to omit them.

2. Step 2: Check each option

   type FilterStrings<T> = { [K in keyof T as T[K] extends string ? K : never]: T[K] } correctly uses 'as' with conditional to keep keys where T[K] extends string; others become never (excluded).

3. Final Answer:

   type FilterStrings<T> = { [K in keyof T as T[K] extends string ? K : never]: T[K] } -> Option A

4. Quick Check:

   Key remapping with 'as' filters keys [OK]

Hint: Use 'as' with conditional to filter keys in mapped types [OK]

Common Mistakes:

• Not using 'as' for key filtering
• Returning never as value instead of key
• Confusing key and value conditions