Why utility types are needed in Typescript

Introduction

Utility types help make your code easier and faster to write by reusing common patterns. They save time and reduce mistakes when working with types.

When you want to change some properties of an object type without rewriting the whole type.

When you need to create a new type based on an existing one but with some changes like making properties optional or readonly.

When you want to pick only some properties from a big type to use in a smaller part of your program.

When you want to combine or modify types quickly without repeating code.

When you want to ensure your code is safer by clearly defining how types should behave.

Syntax

Typescript

type NewType = UtilityType<ExistingType>;

Utility types are built-in TypeScript types that help transform other types.

You use them by passing an existing type inside angle brackets <>.

Examples

This makes all properties of User read-only, so they cannot be changed.

Typescript

type ReadonlyUser = Readonly<User>;

This makes all properties of User optional, so you don't have to provide all of them.

Typescript

type PartialUser = Partial<User>;

This creates a new type with only the name property from User.

Typescript

type UserName = Pick<User, 'name'>;

Sample Program

This program shows how utility types like Readonly, Partial, and Pick change the shape of the User type to fit different needs.

Typescript

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

// Make all properties readonly
const user1: Readonly<User> = {
  id: 1,
  name: "Alice",
  email: "[e-mail]"
};

// user1.name = "Bob"; // Error: Cannot assign to 'name' because it is a read-only property.

// Make all properties optional
const user2: Partial<User> = {
  name: "Bob"
};

// Pick only 'email' property
const userEmail: Pick<User, 'email'> = {
  email: "[e-mail]"
};

console.log(user1);
console.log(user2);
console.log(userEmail);

Important Notes

Utility types help avoid repeating yourself by reusing existing types with small changes.

They improve code safety by clearly showing how types are modified.

Common utility types include Readonly, Partial, Pick, Omit, and more.

Summary

Utility types make working with types easier and faster.

They help create new types by changing existing ones without rewriting.

Using utility types leads to safer and cleaner code.

Practice

1. Why are utility types useful in TypeScript?

easy

A. They replace the need for interfaces and classes.

B. They automatically fix runtime errors in JavaScript code.

C. They help create new types by modifying existing ones without rewriting code.

D. They allow TypeScript to run faster during compilation.

Solution

1. Step 1: Understand utility types purpose

   Utility types let you create new types by transforming existing ones, saving time and effort.

2. Step 2: Compare other options

   Options B, C, and D describe incorrect or unrelated features; utility types do not fix runtime errors, replace interfaces/classes, or speed up compilation.

3. Final Answer:

   They help create new types by modifying existing ones without rewriting code. -> Option C

4. Quick Check:

   Utility types = modify types easily [OK]

Hint: Utility types change types without rewriting them [OK]

Common Mistakes:

• Thinking utility types fix runtime errors
• Confusing utility types with interfaces
• Believing utility types speed up compilation

2. Which of the following is the correct syntax to use the Partial utility type in TypeScript?

easy

A. type Partial<T> = { [P in keyof T]?: T[P] };

B. type Partial<T> = { [P in T]?: keyof T };

C. type Partial<T> = { [P in keyof T]: T[P] };

D. type Partial<T> = { [P in keyof T]?: keyof T };

Solution

1. Step 1: Recall Partial type definition

   Partial makes all properties optional by adding ? to each key in T using mapped types.

2. Step 2: Check each option's correctness

   type Partial<T> = { [P in keyof T]?: T[P] }; correctly uses [P in keyof T]?: T[P]. Others misuse keys or omit optional modifier.

3. Final Answer:

   type Partial<T> = { [P in keyof T]?: T[P] }; -> Option A

4. Quick Check:

   Partial syntax = mapped optional keys [OK]

Hint: Partial adds ? to all keys using mapped types [OK]

Common Mistakes:

• Omitting the optional modifier '?'
• Using wrong key iteration syntax
• Confusing keys and values in mapped types

3. What will be the output type of this code snippet?

interface User {
  id: number;
  name: string;
  age: number;
}

type UserPreview = Pick;

const preview: UserPreview = { id: 1, name: 'Alice' };

medium

A. { id: number; name: string; age: number; }

B. { id: number; name: string; }

C. { id: number; age: number; }

D. { name: string; age: number; }

Solution

1. Step 1: Understand Pick utility type

   Pick creates a new type by selecting only specified keys from the original type.

2. Step 2: Apply Pick to User interface

   Pick results in a type with only 'id' and 'name' properties.

3. Final Answer:

   { id: number; name: string; } -> Option B

4. Quick Check:

   Pick selects keys = {id, name} [OK]

Hint: Pick selects only specified keys from a type [OK]

Common Mistakes:

• Including keys not picked
• Confusing Pick with Omit
• Expecting all original properties

4. Identify the error in this TypeScript code using the Readonly utility type:

interface Config {
  url: string;
  timeout: number;
}

const config: Readonly<Config> = { url: 'api.com', timeout: 1000 };
config.timeout = 2000;

medium

A. Cannot assign to 'timeout' because it is a read-only property.

B. Missing type annotation for 'config'.

C. Readonly utility type is not imported.

D. The object literal is missing required properties.

Solution

1. Step 1: Understand Readonly utility type effect

   Readonly makes all properties of a type immutable (cannot be changed after assignment).

2. Step 2: Analyze the assignment error

   Trying to assign a new value to config.timeout causes a compile-time error because it's read-only.

3. Final Answer:

   Cannot assign to 'timeout' because it is a read-only property. -> Option A

4. Quick Check:

   Readonly blocks property reassignment [OK]

Hint: Readonly properties cannot be reassigned [OK]

Common Mistakes:

• Ignoring immutability of Readonly
• Assuming Readonly needs import
• Confusing Readonly with Partial

5. You want to create a new type from Product where all properties are optional except id which must remain required. Which utility types combination achieves this?

hard

A. type NewProduct = Omit & Pick;

B. type NewProduct = Required<Product> & Partial>;

C. type NewProduct = Omit & Partial<Product>;

D. type NewProduct = Partial> & Pick;

Solution

1. Step 1: Understand the goal

   Make all properties optional except 'id' which stays required.

2. Step 2: Analyze each option

   type NewProduct = Partial> & Pick; omits 'id' from Product, makes the rest partial (optional), then adds back 'id' as required using Pick.

3. Step 3: Why others fail

   type NewProduct = Omit & Pick; omits 'id' from Product but fails to apply Partial, keeping other properties required. type NewProduct = Required<Product> & Partial>; reverses required and partial incorrectly. type NewProduct = Omit & Partial<Product>; omits 'id' but then adds all properties partial, making 'id' missing.

4. Final Answer:

   type NewProduct = Partial<Omit<Product, 'id'>> & Pick<Product, 'id'>; -> Option D

5. Quick Check:

   Omit + Partial + Pick keeps 'id' required [OK]

Hint: Omit optional keys, then add required key back with Pick [OK]

Common Mistakes:

• Using Partial on whole type including required keys
• Confusing order of intersection types
• Forgetting to omit required keys before Partial