Conditional type with generics in Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a conditional type in TypeScript?

A conditional type chooses one type or another based on a condition. It uses syntax like T extends U ? X : Y, meaning if T fits U, use X, else use Y.

beginner

How do generics work with conditional types?

Generics let you write flexible types that depend on input types. When combined with conditional types, you can create types that change based on the generic type passed in.

beginner

Explain this TypeScript type: type IsString<T> = T extends string ? true : false;

This type checks if T is a string. If yes, it becomes true, otherwise false. For example, IsString<string> is true, but IsString<number> is false.

intermediate

What happens if you use a union type with a conditional type?

Conditional types distribute over union types. For example, IsString<string | number> becomes IsString<string> | IsString<number>, which is true | false.

beginner

Why use conditional types with generics?

They let you create smart types that adapt based on input types. This helps catch errors early and makes your code more flexible and clear.

What does this conditional type do? type Check<T> = T extends number ? 'Number' : 'Other';

A Returns 'Number' if T is number, else 'Other'

B Always returns 'Number'

C Always returns 'Other'

D Throws an error

The type checks if T fits number. If yes, it returns 'Number', otherwise 'Other'.

What is the result of Check<string> if Check<T> = T extends number ? 'Number' : 'Other'?

A 'Number'

B number

C string

D 'Other'

Since string does not extend number, the result is 'Other'.

How do conditional types behave with union types like T = string | number?

A They apply to the whole union as one type

B They ignore union types

C They distribute over each union member separately

D They cause a syntax error

Conditional types distribute over unions, applying the condition to each member.

Which syntax correctly defines a conditional type?

A <code>if T then X else Y</code>

B <code>T extends U ? X : Y</code>

C <code>switch(T) { case U: X; default: Y; }</code>

D <code>type T = X | Y;</code>

Conditional types use the syntax T extends U ? X : Y.

What is the benefit of using conditional types with generics?

A They make types flexible and adaptive

B They slow down compilation

C They remove type safety

D They are only for runtime checks

Conditional types with generics create flexible types that adapt based on input types.

Explain how conditional types work with generics in TypeScript.

Think about how you can check if a generic type fits another type and return different types.

Describe what happens when a conditional type is used with a union type generic.

Remember how unions split the conditional check for each type inside.

Practice

1. What does a conditional type with generics in TypeScript do?

easy

A. It creates a new variable with a fixed type.

B. It selects one type or another based on a condition using generic types.

C. It runs a function only if a condition is true.

D. It converts all types to strings.

Solution

1. Step 1: Understand conditional types

   Conditional types choose between two types depending on a condition.

2. Step 2: Understand generics

   Generics allow types to be flexible and work with many types.

3. Final Answer:

   It selects one type or another based on a condition using generic types. -> Option B

4. Quick Check:

   Conditional type with generics = Selects type based on condition [OK]

Hint: Remember: conditional types pick types, generics make them flexible [OK]

Common Mistakes:

• Thinking conditional types run code instead of selecting types
• Confusing generics with fixed types
• Assuming conditional types convert values

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

easy

A. type Result<T> = T extends string ? number : boolean;

B. function Result<T> = T ? number : boolean;

C. let Result<T> = T extends string ? number : boolean;

D. class Result<T> = T extends string ? number : boolean;

Solution

1. Step 1: Identify correct conditional type syntax

   Conditional types use the syntax: type Name<T> = T extends Condition ? TrueType : FalseType;

2. Step 2: Check each option

   type Result<T> = T extends string ? number : boolean; matches the correct syntax. Others use function, let, or class incorrectly.

3. Final Answer:

   type Result<T> = T extends string ? number : boolean; -> Option A

4. Quick Check:

   Correct conditional type syntax = type Result<T> = T extends string ? number : boolean; [OK]

Hint: Conditional types use 'type' keyword with generic and '? :' [OK]

Common Mistakes:

• Using function or class instead of type
• Missing the 'extends' keyword
• Using let instead of type

3. What is the type of Result<string> given this code?

type Result<T> = T extends number ? boolean : string;

medium

A. boolean

B. never

C. number

D. string

Solution

1. Step 1: Check the condition for T = string

   The condition is T extends number. Since string does not extend number, the condition is false.

2. Step 2: Determine the resulting type

   Because the condition is false, the type after the colon is chosen, which is string.

3. Final Answer:

   string -> Option D

4. Quick Check:

   string extends number? No, so type = string [OK]

Hint: Check if generic type matches condition; else pick false type [OK]

Common Mistakes:

• Assuming string extends number
• Choosing the true type instead of false
• Confusing extends with assignment

4. Identify the error in this conditional type with generics:

type Check<T> = T extends ? string : number;

medium

A. Incorrect use of generic parameter

B. Missing colon ':' after condition

C. Missing type after 'extends' keyword

D. Using 'type' instead of 'interface'

Solution

1. Step 1: Analyze the conditional type syntax

   The syntax requires a type after 'extends' to check the condition.

2. Step 2: Identify the missing part

   Here, 'T extends ?' is missing the type to compare with, causing a syntax error.

3. Final Answer:

   Missing type after 'extends' keyword -> Option C

4. Quick Check:

   Conditional type needs a type after 'extends' [OK]

Hint: Always put a type after 'extends' in conditional types [OK]

Common Mistakes:

• Leaving out the type after 'extends'
• Confusing '?' placement
• Using interface instead of type for conditional types

5. Given this code, what is the type of Output?

type IsArray<T> = T extends any[] ? 'array' : 'not array';
type Output = IsArray<string[] | number>;

hard

A. 'array' | 'not array'

B. 'array'

C. 'not array'

D. string[] | number

Solution

1. Step 1: Understand conditional type with union

   When conditional types receive a union, they distribute over each member separately.

2. Step 2: Apply condition to each union member

   string[] extends any[]? Yes, so 'array'. number extends any[]? No, so 'not array'.

3. Step 3: Combine results

   The result is the union of both: 'array' | 'not array'.

4. Final Answer:

   'array' | 'not array' -> Option A

5. Quick Check:

   Conditional distributes over union = 'array' | 'not array' [OK]

Hint: Conditional types distribute over unions automatically [OK]

Common Mistakes:

• Assuming single result for union input
• Forgetting distribution over union types
• Confusing output with input types