Utility Types

Welcome to the next lesson! In this lesson, you’ll learn about utility types, built-in TypeScript features that simplify and enhance type transformations. Let’s get started!

What Are Utility Types?

Utility types are pre-defined types provided by TypeScript to perform common type transformations, such as making properties optional, readonly, or picking specific properties from a type.

Example:

type User = {
  name: string;
  age: number;
  email: string;
};

type PartialUser = Partial<User>;

let user: PartialUser = { name: "Alice" }; 
// Only 'name' is provided

Partial

The Partial utility type makes all properties of a type optional. Example:

Task: Create a type with the Partial utility and use it to define a variable.

type User = {
  name: string;
  age: number;
};

type OptionalUser = Partial<User>;

let user: OptionalUser = { name: "Bob" }; 
// 'age' is optional

Readonly

The Readonly utility type makes all properties of a type immutable. Example:

Task: Use the Readonly utility type to create an immutable object.

type User = {
  name: string;
  age: number;
};

type ReadonlyUser = Readonly<User>;

let user: ReadonlyUser = { name: "Alice", age: 25 };
// user.age = 30; 
// Error: Cannot assign to 'age' because it is a read-only property

Pick

The Pick utility type selects specific properties from a type. Example:

Task: Use the Pick utility type to create a type with only selected properties.

type User = {
  name: string;
  age: number;
  email: string;
};

type UserNameAndEmail = Pick<User, "name" | "email">;

let user: UserNameAndEmail = { name: "Alice", email: "alice@example.com" };

Omit

The Omit utility type excludes specific properties from a type. Example:

Task: Use the Omit utility type to exclude a property from a type.

type User = {
  name: string;
  age: number;
  email: string;
};

type UserWithoutEmail = Omit<User, "email">;

let user: UserWithoutEmail = { name: "Bob", age: 30 };

Record

The Record utility type creates a type with a set of keys and a specified type for the values. Example:

Task: Use the Record utility type to create a mapping between keys and values.

type Role = "admin" | "user" | "guest";

type Permissions = Record<Role, string[]>;

let rolePermissions: Permissions = {
  admin: ["read", "write", "delete"],
  user: ["read", "write"],
  guest: ["read"],
};

Required

The Required utility type makes all properties of a type mandatory. Example:

Task: Use the Required utility type to make all properties mandatory.

type User = {
  name?: string;
  age?: number;
};

type FullUser = Required<User>;

let user: FullUser = { name: "Alice", age: 30 }; 
// Both 'name' and 'age' are required

Great Job!

Congratulations! You’ve learned about TypeScript’s built-in utility types, including Partial, Readonly, Pick, Omit, and more. These utilities make working with types faster and easier. In the next lesson, we’ll dive into advanced mapped types. Let’s keep coding!