Combining utility types in Typescript

Introduction

Combining utility types helps you create new types by mixing existing ones. This makes your code flexible and easier to manage.

When you want to make some properties optional and others required in an object.

When you need to pick only certain properties from a type and also make some readonly.

When you want to exclude some properties from a type and then add new ones.

When you want to reuse parts of types but change how some properties behave.

Syntax

Typescript

type NewType = UtilityType1<UtilityType2<OriginalType>>;

You can nest utility types inside each other to combine their effects.

Common utility types include Partial, Pick, Omit, Readonly, Required, and Record.

Examples

This makes all properties of T optional and readonly.

Typescript

type PartialReadonly<T> = Readonly<Partial<T>>;

This picks only name and age properties from T and makes them required.

Typescript

type PickRequired<T> = Required<Pick<T, 'name' | 'age'>>;

This removes the password property from T and makes the rest readonly.

Typescript

type OmitAndReadonly<T> = Readonly<Omit<T, 'password'>>;

Sample Program

This program creates a new type SafeUser by removing the password property from User and making all remaining properties readonly. Then it creates a user object of this type and prints it.

Typescript

interface User {
  id: number;
  name: string;
  email?: string;
  password: string;
}

type SafeUser = Readonly<Omit<User, 'password'>>;

const user: SafeUser = {
  id: 1,
  name: 'Alice',
  email: '[e-mail]'
};

// user.id = 2; // Error: Cannot assign to 'id' because it is a read-only property

console.log(user);

Important Notes

Combining utility types lets you build precise types without repeating code.

Remember that the order of utility types matters. For example, Readonly> is different from Partial>.

Use TypeScript's error messages to understand how your combined types behave.

Summary

Combining utility types helps create new, flexible types by mixing existing ones.

You can nest utility types like Partial, Readonly, Pick, and Omit.

This technique keeps your code clean and easy to update.

Practice

1. Which utility type combination creates a type with all properties optional and readonly in TypeScript?

easy

A. Readonly<Partial<T>>

B. Required<Readonly<T>>

C. Pick<T, keyof T>

D. Omit<T, keyof T>

Solution

1. Step 1: Understand Partial and Readonly

   Partial<T> makes all properties optional, and Readonly<T> makes all properties readonly.

2. Step 2: Combine utility types correctly

   Wrapping Partial<T> inside Readonly<> makes all optional properties readonly as well.

3. Final Answer:

   Readonly<Partial<T>> -> Option A

4. Quick Check:

   Readonly + Partial = Readonly<Partial<T>> [OK]

Hint: Wrap Partial inside Readonly for optional readonly props [OK]

Common Mistakes:

• Reversing the order of Partial and Readonly
• Using Pick or Omit instead of Partial/Readonly
• Assuming Pick makes properties optional

2. Which of the following is the correct syntax to create a type that omits properties 'a' and 'b' from type T and makes the rest readonly?

easy

A. Partial<Omit<T, 'a' | 'b'>>

B. Omit<Partial<T>, 'a' | 'b'>

C. Readonly<Omit<T, 'a' | 'b'>>

D. Pick<Readonly<T>, 'a' | 'b'>

Solution

1. Step 1: Understand Omit and Readonly

   Omit<T, 'a' | 'b'> removes properties 'a' and 'b' from T. Readonly<> makes all properties readonly.

2. Step 2: Apply Readonly after Omit

   Applying Readonly to the result of Omit makes the remaining properties readonly.

3. Final Answer:

   Readonly<Omit<T, 'a' | 'b'>> -> Option C

4. Quick Check:

   Omit then Readonly = Readonly<Omit<T, 'a' | 'b'>> [OK]

Hint: Omit first, then wrap with Readonly for readonly filtered props [OK]

Common Mistakes:

• Applying Omit after Readonly (wrong order)
• Using Pick instead of Omit
• Forgetting to use quotes around property names

3. Given the type type T = { a: number; b: string; c: boolean; }, what is the resulting type of Partial<Pick<T, 'a' | 'c'>>?

medium

A. { a?: number; c?: boolean; }

B. { a: number; c: boolean; }

C. { a?: number; b?: string; c?: boolean; }

D. { b?: string; }

Solution

1. Step 1: Apply Pick to select properties

   Pick<T, 'a' | 'c'> selects only properties 'a' and 'c' from T.

2. Step 2: Apply Partial to make selected properties optional

   Partial<> makes 'a' and 'c' optional, so the type becomes { a?: number; c?: boolean; }.

3. Final Answer:

   { a?: number; c?: boolean; } -> Option A

4. Quick Check:

   Partial + Pick = optional picked props [OK]

Hint: Pick selects keys, Partial makes them optional [OK]

Common Mistakes:

• Including property 'b' which was not picked
• Forgetting Partial makes properties optional
• Assuming Partial affects all original properties

4. Identify the error in this type combination: type U = Partial<Readonly<Omit<T, 'x'>>>

medium

A. Partial cannot be applied to Readonly types

B. No error; the type combination is valid

C. Readonly should be applied after Partial for optional readonly props

D. Omit must be applied after Partial

Solution

1. Step 1: Analyze the order of utility types

   The type applies Omit first, removing property 'x', then Readonly to make remaining props readonly, then Partial to make them optional.

2. Step 2: Check if this order is valid

   This order is valid and results in optional readonly properties except 'x' which is omitted.

3. Final Answer:

   No error; the type combination is valid -> Option B

4. Quick Check:

   Omit -> Readonly -> Partial is valid [OK]

Hint: Utility types can be nested in any valid order [OK]

Common Mistakes:

• Thinking Partial cannot follow Readonly
• Assuming Omit must be last
• Confusing order of utility types

5. You want to create a type from T that has only properties 'id' and 'name' readonly, and all other properties optional. Which combination achieves this?

hard

A. Partial<Readonly<Pick<T, 'id' | 'name'>>> && Omit<T, 'id' | 'name'>

B. Pick<Readonly<T>, 'id' | 'name'> && Partial<Omit<T, 'id' | 'name'>>

C. Readonly<Pick<T, 'id' | 'name'>> && Partial<Omit<T, 'id' | 'name'>>

D. Readonly<Pick<T, 'id' | 'name'>> & Partial<Omit<T, 'id' | 'name'>>

Solution

1. Step 1: Make 'id' and 'name' readonly

   Use Readonly<Pick<T, 'id' | 'name'>> to select and make these properties readonly.

2. Step 2: Make all other properties optional

   Use Partial<Omit<T, 'id' | 'name'>> to make the rest optional.

3. Step 3: Combine with intersection (&)

   Use intersection & to merge both types into one.

4. Final Answer:

   Readonly<Pick<T, 'id' | 'name'>> & Partial<Omit<T, 'id' | 'name'>> -> Option D

5. Quick Check:

   Readonly Pick & Partial Omit = desired type [OK]

Hint: Use intersection of Readonly Pick and Partial Omit [OK]

Common Mistakes:

• Using logical AND (&&) instead of intersection (&)
• Applying Partial to readonly properties
• Omitting intersection operator