Exclude type in Typescript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Exclude type example?

Consider the following TypeScript code using Exclude. What is the type of Result?

Typescript

type Letters = 'a' | 'b' | 'c' | 'd';
type Result = Exclude<Letters, 'a' | 'd'>;

// What is the type of Result?

A "b" | "c" | "d"

B "b" | "c"

C "a" | "b" | "c" | "d"

D "a" | "d"

💡 Hint

The Exclude type removes the types on the right from the union on the left.

The Exclude utility type removes 'a' and 'd' from the union 'a' | 'b' | 'c' | 'd', leaving 'b' | 'c'.

❓ Predict Output

intermediate

What does this Exclude type produce?

Given this code, what is the type of Filtered?

Typescript

type Status = 'success' | 'error' | 'loading';
type Filtered = Exclude<Status, 'loading'>;

A "success" | "error"

B "loading"

C "success" | "error" | "loading"

D never

💡 Hint

Exclude removes the specified type from the union.

Removing 'loading' from Status leaves 'success' | 'error'.

❓ Predict Output

advanced

What is the output of this Exclude with object keys?

What is the resulting type of KeysWithoutId?

Typescript

type Obj = { id: number; name: string; age: number };
type Keys = keyof Obj;
type KeysWithoutId = Exclude<Keys, 'id'>;

A "name" | "age"

B "id" | "name" | "age"

C "id"

D never

💡 Hint

Use keyof to get keys, then exclude 'id'.

keyof Obj is 'id' | 'name' | 'age'. Excluding 'id' leaves 'name' | 'age'.

❓ Predict Output

advanced

What error does this code raise?

What error will this code produce?

Typescript

type A = 'x' | 'y';
type B = Exclude<A, 'z'>;

const test: B = 'z';

A No error, assignment is valid.

B SyntaxError: Unexpected token

C Type '"z"' is not assignable to type '"x" | "y"'.

D TypeError: Exclude cannot exclude 'z'

💡 Hint

Check if the assigned value is part of the type after exclusion.

Since 'z' is not in 'x' | 'y', assigning 'z' to test causes a type error.

🧠 Conceptual

expert

How many items are in the resulting union type?

Given this code, how many string literal types remain in Remaining?

Typescript

type All = 'red' | 'green' | 'blue' | 'yellow' | 'black';
type Remove = 'green' | 'yellow' | 'white';
type Remaining = Exclude<All, Remove>;

A 2

B 4

C 5

D 3

💡 Hint

Count how many items from All are not in Remove.

Remove includes 'green' and 'yellow' which are removed from All. The remaining are 'red', 'blue', and 'black', so 3 items.

Practice

1. What does the TypeScript Exclude utility type do?

easy

A. Converts a type to a string

B. Adds new types to a union type

C. Removes specific types from a union type

D. Creates a readonly version of a type

Solution

1. Step 1: Understand the purpose of Exclude

   Exclude is designed to remove certain types from a union type.

2. Step 2: Compare with other utility types

   Unlike adding or converting types, Exclude specifically filters out unwanted types.

3. Final Answer:

   Removes specific types from a union type -> Option C

4. Quick Check:

   Exclude = Remove types [OK]

Hint: Exclude filters out unwanted types from unions [OK]

Common Mistakes:

• Thinking it adds types instead of removing
• Confusing with Partial or Readonly utility types
• Assuming it converts types to strings

2. Which of the following is the correct syntax to exclude type 'b' from the union 'a' | 'b' | 'c'?

easy

A. type Result = Exclude<'a' | 'b' | 'c', ['b']>;

B. type Result = Exclude<'a' | 'b' | 'c', 'b'>;

C. type Result = Exclude<'a' | 'b' | 'c'>;

D. type Result = Exclude<'a' | 'b' | 'c', 'd'>;

Solution

1. Step 1: Check the syntax of Exclude

   The correct syntax is Exclude<UnionType, ExcludedType>.

2. Step 2: Match the correct exclusion

   type Result = Exclude<'a' | 'b' | 'c', 'b'>; correctly excludes 'b' from the union 'a' | 'b' | 'c'.

3. Final Answer:

   type Result = Exclude<'a' | 'b' | 'c', 'b'>; -> Option B

4. Quick Check:

   Exclude syntax = Exclude<Union, TypeToRemove> [OK]

Hint: Use Exclude syntax [OK]

Common Mistakes:

• Using array syntax for second parameter
• Omitting the second parameter
• Excluding a type not in the union

3. What is the resulting type of this code?

type Letters = 'x' | 'y' | 'z';
type Result = Exclude;

medium

A. 'x'

B. 'x' | 'y' | 'z'

C. 'y' | 'z'

D. never

Solution

1. Step 1: Identify the original union type

   Letters is 'x' | 'y' | 'z'.

2. Step 2: Apply Exclude to remove 'y' and 'z'

   Removing 'y' and 'z' leaves only 'x'.

3. Final Answer:

   'x' -> Option A

4. Quick Check:

   Exclude removes 'y' and 'z', leaving 'x' [OK]

Hint: Exclude removes all listed types from the union [OK]

Common Mistakes:

• Thinking it keeps excluded types
• Confusing with intersection types
• Assuming result is never when some types remain

4. Identify the error in this TypeScript code:

type Colors = 'red' | 'green' | 'blue';
type NoGreen = Exclude<Colors>;

medium

A. Missing second parameter in Exclude

B. Colors is not a union type

C. Exclude cannot be used with string literals

D. No error, code is correct

Solution

1. Step 1: Check the Exclude syntax

   Exclude requires two parameters: the union type and the type(s) to exclude.

2. Step 2: Identify the missing parameter

   The code only provides one parameter, missing the second one to exclude.

3. Final Answer:

   Missing second parameter in Exclude -> Option A

4. Quick Check:

   Exclude needs two types: Union and Excluded [OK]

Hint: Exclude always needs two type parameters [OK]

Common Mistakes:

• Forgetting the second parameter
• Assuming Exclude works with one argument
• Confusing Exclude with other utility types

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

type Status = 'success' | 'error' | 'pending' | 'cancelled';
type Filtered = Exclude;

hard

A. 'error' | 'cancelled' | 'unknown'

B. 'success' | 'pending' | 'unknown'

C. never

D. 'success' | 'pending'

Solution

1. Step 1: Identify the original union and excluded types

   Status is 'success' | 'error' | 'pending' | 'cancelled'. We exclude 'error', 'cancelled', and 'unknown'.

2. Step 2: Remove excluded types from the union

   'error' and 'cancelled' are removed. 'unknown' is not in Status, so it has no effect.

3. Final Answer:

   'success' | 'pending' -> Option D

4. Quick Check:

   Exclude removes only matching types from union [OK]

Hint: Exclude only removes types present in the union [OK]

Common Mistakes:

• Including excluded types in the result
• Adding excluded types not in the union
• Assuming result is never if unknown type excluded