Utility Types

Partial, Required, Pick, Omit

Partial

Makes all properties optional:

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

// All properties are now optional
type PartialUser = Partial<User>;
// { name?: string; age?: number; email?: string }

// Useful for update functions
function updateUser(id: number, updates: Partial<User>) {
  // Can update any subset of properties
}

updateUser(1, { name: "Bob" }); // OK
updateUser(1, { age: 30, email: "bob@example.com" }); // OK

Required

Makes all properties required:

type OptionalUser = {
  name?: string;
  age?: number;
  email?: string;
};

// All properties are now required
type RequiredUser = Required<OptionalUser>;
// { name: string; age: number; email: string }

Pick

Selects specific properties:

type User = {
  id: number;
  name: string;
  email: string;
  password: string;
};

// Only name and email
type UserPreview = Pick<User, "name" | "email">;
// { name: string; email: string }

// For API responses
type UserProfile = Pick<User, "id" | "name" | "email">;

Omit

Removes specific properties:

type User = {
  id: number;
  name: string;
  email: string;
  password: string;
};

// Everything except password
type SafeUser = Omit<User, "password">;
// { id: number; name: string; email: string }

// For form inputs (no id)
type CreateUserInput = Omit<User, "id">;

Record and Readonly

Record

Constructs an object type with specific keys and values:

// Record<Keys, Values>
type Scores = Record<string, number>;

const scores: Scores = {
  math: 95,
  english: 88,
  science: 92
};

// With union keys
type Page = "home" | "about" | "contact";
type PageContent = Record<Page, string>;

const content: PageContent = {
  home: "Welcome",
  about: "About us",
  contact: "Contact info"
};

// Record with complex values
type UserMap = Record<number, User>;
const users: UserMap = {
  1: { id: 1, name: "Alice" },
  2: { id: 2, name: "Bob" }
};

Readonly

Makes all properties immutable:

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

const user: Readonly<User> = {
  name: "Alice",
  age: 30
};

// user.name = "Bob"; // Error!

// ReadonlyArray
const numbers: ReadonlyArray<number> = [1, 2, 3];
// numbers.push(4); // Error!

// ReadonlyMap
const map = new ReadonlyMap<string, number>();
// map.set("key", 1); // Error!

Readonly vs Const

// const prevents reassignment
const x = 5;
// x = 6; // Error!

// const doesn't prevent mutation
const arr = [1, 2, 3];
arr.push(4); // OK!

// Readonly prevents mutation
const readonlyArr: readonly number[] = [1, 2, 3];
// readonlyArr.push(4); // Error!

Mapped Types

Mapped types transform existing types by iterating over their properties.

Basic Mapped Type

type Optional<T> = {
  [K in keyof T]?: T[K];
};

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

type OptionalUser = Optional<User>;
// { name?: string; age?: number }

Readonly Mapped Type

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K];
};

type ReadonlyUser = MyReadonly<User>;
// { readonly name: string; readonly age: number }

Removing Modifiers

// Remove readonly
type Mutable<T> = {
  -readonly [K in keyof T]: T[K];
};

// Remove optional
type Concrete<T> = {
  [K in keyof T]-?: T[K];
};

Built-in Mapped Types

// Partial<T>: { [K in keyof T]?: T[K] }
// Required<T>: { [K in keyof T]-?: T[K] }
// Readonly<T>: { readonly [K in keyof T]: T[K] }
// Record<K, T>: { [P in K]: T }

Custom Utility Types

// Make specific properties optional
type PartialBy<T, K extends keyof T> = Omit<T, K> &
  Partial<Pick<T, K>>;

// Make specific properties required
type RequiredBy<T, K extends keyof T> = Omit<T, K> &
  Required<Pick<T, K>>;