Exclude type in Typescript

Introduction

The Exclude type helps you remove specific types from a group of types. It makes your code clearer and safer by excluding unwanted types.

When you want to create a new type without certain values from an existing type.

When you want to prevent some values from being used in a function or variable.

When you want to narrow down a type by removing options that don't apply.

When you want to handle only specific cases in your code by excluding others.

Syntax

Typescript

Exclude<UnionType, ExcludedMembers>

UnionType is the original set of types.

ExcludedMembers are the types you want to remove from UnionType.

Examples

This removes 'green' and 'blue' from Colors, so PrimaryColors is just 'red'.

Typescript

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

This excludes 2 and 3 from the numbers, leaving 1 and 4.

Typescript

type Numbers = 1 | 2 | 3 | 4;
type WithoutTwoAndThree = Exclude<Numbers, 2 | 3>;

This removes boolean from the union, keeping only string and number.

Typescript

type Mixed = string | number | boolean;
type OnlyStringAndNumber = Exclude<Mixed, boolean>;

Sample Program

This program defines a type Pets with four animals. Then it creates NoFish by excluding 'fish'. The function adoptPet only accepts pets except 'fish'. Trying to adopt 'fish' causes an error.

Typescript

type Pets = 'dog' | 'cat' | 'fish' | 'bird';
type NoFish = Exclude<Pets, 'fish'>;

function adoptPet(pet: NoFish) {
  console.log(`You adopted a ${pet}.`);
}

adoptPet('dog');
// adoptPet('fish'); // This line will cause a TypeScript error

Important Notes

Exclude works only with union types.

It helps catch mistakes early by preventing unwanted types.

Summary

Exclude removes specific types from a union.

It makes your types more precise and your code safer.

Use it when you want to block certain values from a type.

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