TypeScript Utility Types — Complete Interview Guide

The Partial Family — Modifying Optionality

// Partial<T> — makes every property optional
interface User { id: number; name: string; email: string; }
type PartialUser = Partial<User>;
// { id?: number; name?: string; email?: string; }

// Essential for update/patch functions:
function updateUser(id: number, changes: Partial<User>): User { /* ... */ }
updateUser(1, { name: "Bob" }); // Only name — perfectly valid

// Required<T> — makes every property required (removes ?)
interface Config { host?: string; port?: number; debug?: boolean; }
type StrictConfig = Required<Config>;
// { host: string; port: number; debug: boolean; }

// Readonly<T> — makes every property readonly
const config: Readonly<Config> = { host: "localhost", port: 3000 };
config.host = "example.com"; // Error: Cannot assign to 'host' — readonly

Pick and Omit — Selecting Properties

interface Product {
  id: number;
  title: string;
  description: string;
  price: number;
  internalCode: string; // sensitive — don't expose to client
}

// Pick — include only listed keys
type ProductSummary = Pick<Product, "id" | "title" | "price">;
// { id: number; title: string; price: number; }

// Omit — exclude listed keys (dual of Pick)
type PublicProduct = Omit<Product, "internalCode">;
// { id: number; title: string; description: string; price: number; }

// Prefer Omit when you want to exclude a few sensitive fields from a large type
// Prefer Pick when you want to select a small subset from a large type

Record — Typed Dictionaries

// Record<K, V> — a type with keys K and values V
type UserMap = Record<string, User>;
// { [key: string]: User }

// More precise — limit the keys to a union
type Permission = "read" | "write" | "delete";
type RolePermissions = Record<Permission, boolean>;
// { read: boolean; write: boolean; delete: boolean; }
// TypeScript will error if you miss a key — exhaustive check

const adminPerms: RolePermissions = { read: true, write: true, delete: true };
const guestPerms: RolePermissions = { read: true, write: false }; // Error: missing 'delete'

Exclude and Extract — Filtering Union Members

type AllStatus = "active" | "inactive" | "deleted" | "banned";

// Exclude removes matching members from a union
type VisibleStatus = Exclude<AllStatus, "deleted" | "banned">;
// "active" | "inactive"

// Extract keeps only matching members
type ProblematicStatus = Extract<AllStatus, "deleted" | "banned">;
// "deleted" | "banned"

// NonNullable removes null and undefined
type MaybeString = string | null | undefined;
type DefiniteString = NonNullable<MaybeString>;
// string

// Practical use: filtering a union to only object types
type OnlyFunctions = Extract<string | number | (() => void), Function>;
// () => void

ReturnType, Parameters, and InstanceType

function createUser(name: string, age: number): User { /* ... */ }

// ReturnType — extracts the return type of a function
type CreatedUser = ReturnType<typeof createUser>;
// User

// Parameters — extracts a tuple of the parameter types
type CreateUserArgs = Parameters<typeof createUser>;
// [name: string, age: number]

// InstanceType — extracts the instance type of a constructor
class UserService { getUser(id: number): User { /* ... */ } }
type UserServiceInstance = InstanceType<typeof UserService>;
// UserService

// These are invaluable when you don't control the source types —
// you can derive types from functions/classes you import from libraries

Implementing Utility Types Yourself

Every built-in utility type is implemented using mapped or conditional types. Understanding the implementations is a strong interview signal:

// How Partial is implemented in TypeScript's lib.d.ts
type MyPartial<T> = {
  [P in keyof T]?: T[P];
};

// How Required is implemented
type MyRequired<T> = {
  [P in keyof T]-?: T[P]; // -? removes the optional modifier
};

// How Readonly is implemented
type MyReadonly<T> = {
  readonly [P in keyof T]: T[P];
};

// How Pick is implemented
type MyPick<T, K extends keyof T> = {
  [P in K]: T[P];
};

// How Record is implemented
type MyRecord<K extends keyof any, T> = {
  [P in K]: T;
};

// How Exclude is implemented (conditional type distributing over union)
type MyExclude<T, U> = T extends U ? never : T;