Exclude type in Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the Exclude<T, U> type do in TypeScript?

It creates a new type by removing from T all types that are assignable to U. Think of it as filtering out unwanted types from a set.

beginner

Given type A = 'a' | 'b' | 'c' and type B = 'a' | 'c', what is Exclude<A, B>?

The result is 'b' because 'a' and 'c' are removed from A since they are in B.

intermediate

How can Exclude help when working with union types?

It helps you create a new type by excluding certain members from a union, making your types more precise and avoiding unwanted values.

beginner

Is Exclude<string | number, number> equivalent to string?

Yes. It removes number from the union, leaving only string.

intermediate

Can Exclude be used with non-union types?

Yes, but if T is not a union, it either returns T if it is not assignable to U, or never if it is assignable.

What is the result of Exclude<'x' | 'y' | 'z', 'y' | 'a'>?

A 'x' | 'z'

B 'y' | 'a'

C 'x' | 'y' | 'z'

D 'a'

The type removes 'y' from the first union. Since 'a' is not in the first union, only 'y' is removed, leaving 'x' and 'z'.

Which utility type removes types from a union?

A Pick

B Partial

C Exclude

D Record

Exclude removes types from a union. The others serve different purposes.

What does Exclude<number | string, string> evaluate to?

A number

B string

C number | string

D never

It removes string from the union, leaving only number.

If T is 'a' and U is 'a', what is Exclude<T, U>?

A unknown

B 'a'

C string

D never

Since T is assignable to U, it is excluded, resulting in never.

Can Exclude be used to exclude types other than string literals?

A No, only string literals

B Yes, it works with any types

C Only with numbers

D Only with boolean

Exclude works with any types, including primitives, objects, and unions.

Explain how the Exclude type works in TypeScript and give a simple example.

Think about filtering out unwanted types from a set.

Describe a practical scenario where using Exclude would help improve your TypeScript code.

Consider when you want to remove some options from a list of possible values.

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