Utility Types

Learning objectives#

• Transform object types with Partial, Required, Readonly
• Select properties with Pick and Omit
• Build dictionaries with Record
• Filter unions with Exclude, Extract and NonNullable
• Read function types with ReturnType, Parameters and Awaited

Explanation#

Partial<T> makes every property optional (great for update/patch payloads). Required<T> does the opposite. Readonly<T> makes all properties read-only.

Pick<T, "a" | "b"> keeps only those keys; Omit<T, "password"> removes keys.

Record<K, V> builds an object type with keys K and values V: Record<Role, string[]>.

Union filters: Exclude<U, X> removes members, Extract<U, X> keeps matching ones, NonNullable<T> removes null and undefined.

Function helpers: ReturnType<typeof fn>, Parameters<typeof fn>, and Awaited<T> unwraps a Promise type.

Syntax#

1type UserUpdate = Partial<User>;
2type PublicUser = Omit<User, 'password'>;
3type Preview = Pick<User, 'id' | 'name'>;

Code example: One model, many derived types#

1interface User {
2  id: number;
3  name: string;
4  email: string;
5  password: string;
6  role: 'admin' | 'editor' | 'viewer';
7}
8

9type NewUser = Omit<User, 'id'>;                 // for create forms
10type UserUpdate = Partial<Omit<User, 'id'>>;     // for PATCH requests
11type PublicUser = Omit<User, 'password'>;        // safe to send to the client
12type UserPreview = Pick<User, 'id' | 'name'>;    // for lists
13

14type Role = User['role'];
15type Permissions = Record<Role, string[]>;
16const permissions: Permissions = {
17  admin: ['*'],
18  editor: ['posts:write'],
19  viewer: ['posts:read'],
20};                                               // ✗ if any role is missing
21

22type NonAdmin = Exclude<Role, 'admin'>;          // 'editor' | 'viewer'
23type MaybeEmail = string | null | undefined;
24type Email = NonNullable<MaybeEmail>;            // string
25

26async function fetchUser(id: number): Promise<PublicUser> {
27  return { id, name: 'Asha', email: 'a@x.in', role: 'viewer' };
28}
29type FetchArgs = Parameters<typeof fetchUser>;           // [id: number]
30type Fetched = Awaited<ReturnType<typeof fetchUser>>;    // PublicUser
31

32function updateUser(id: number, changes: UserUpdate) { /* … */ }
33updateUser(1, { name: 'Asha V' });               // ✓ only what changed
34updateUser(1, { id: 9 });                        // ✗ 'id' does not exist in type 'Partial<Omit<User, "id">>'

All derived types follow the User interface automatically. updateUser accepts partial changes but rejects changing the id; the Permissions object must list every role.

This example is illustrative. Copy or download it and run it in your own environment; the expected output is shown above.

Step-by-step explanation#

1. Omit<User, "id"> describes data for creating a user (the database assigns the id).
2. Partial<Omit<…>> allows sending only changed fields.
3. PublicUser removes the password before data leaves the server.
4. Record<Role, string[]> forces a permissions entry for every role.
5. Exclude and NonNullable filter unions.
6. Parameters, ReturnType and Awaited read types from an existing function.

Real-world use case#

Common mistakes#

Best practices#

• Keep one source model and derive DTOs with utility types
• Use Record<Union, V> to force exhaustive maps
• Use Awaited<ReturnType<typeof fn>> instead of re-declaring result types
• Combine utilities, but name the result for readability

Remember this#

Practice exercise#

1interface Product { id: number; name: string; price: number; stock: number }
2

3type ProductForm = Omit<Product, 'id'>;
4type ProductPatch = Partial<ProductForm>;
5type StockMap = Record<Product['name'], Product['stock']>; // Record<string, number>

Mini quiz#

Want more? Practise all TypeScript MCQs · TypeScript interview questions

Related topics#

My notes#

Saved in this browser.