TypeScript•November 13, 202511 min read
TypeScript Utility Types Deep Dive
Alex Kim
Published November 13, 2025
Master Partial, Pick, Omit, Record, Exclude, Extract, ReturnType, and more — with real-world patterns and best practices.
1. Introduction
You don’t need to write every type from scratch.
TypeScript ships with built-in utility types — like Partial<T>, Pick<T, K>, Record<K, T>, and even union manipulators like Exclude<T, U>.
They transform, filter, and compose types with surgical precision.
Let’s go deep. With real-world examples you’ll use every day.
2. Core Utility Types: Object Transformation
| Utility | What It Does | Use Case |
|---|---|---|
| Partial<T> | Makes all properties optional | Form updates, patch APIs |
| Required<T> | Makes all properties required | Config validation |
| Pick<T, K> | Select specific keys | DTOs, props subsets |
| Omit<T, K> | Remove specific keys | Hide internal fields |
| Record<K, T> | Map keys to type | Dictionaries, lookups |
2.1 Partial<T>: Update Without Full Object
ts
1
2
3
4
5
6
7
8
9
10
interface User { id: string; name: string; email: string; role: 'admin' | 'user';}function updateUser(id: string, changes: Partial<User>) {// Only update provided fields}2.2 Required<T>: Enforce All Fields
ts
1
2
3
4
5
6
7
8
9
interface Config { apiUrl?: string; timeout?: number;}const appConfig: Required<Config> = { apiUrl: 'https://api.example.com', timeout: 5000,};2.3 Pick<T, K>: Extract What You Need
ts
1
2
3
4
5
6
7
8
interface User { id: string; name: string; email: string; password: string;}type PublicUser = Pick<User, 'id' | 'name' | 'email'>;2.4 Omit<T, K>: Remove What You Don't Want
ts
1
2
type UserWithoutPassword = Omit<User, 'password'>;// → { id: string; name: string; email: string; }2.5 Record<K, T>: Type-Safe Dictionaries
ts
1
2
3
4
5
const statusLabels: Record<'pending' | 'success' | 'error', string> = { pending: 'Đang xử lý', success: 'Thành công', error: 'Lỗi',};3. Advanced Utility Types: Union & Function Magic
These work with unions, functions, and classes.
| Utility | What It Does | Use Case |
|---|---|---|
| Exclude<T, U> | Remove U from T union | Filter event types |
| Extract<T, U> | Keep only types assignable to U | Extract string literals |
| NonNullable<T> | Remove null and undefined | API responses |
| ReturnType<T> | Get function return type | Type-safe factories |
| Parameters<T> | Get function parameter tuple | HOC, mocks |
| InstanceType<T> | Get instance type of class | DI, services |
3.1 Exclude<T, U>: Filter Out Types
ts
1
2
3
4
type Event = 'click' | 'hover' | 'scroll' | 'keydown';type MouseEvent = Exclude<Event, 'keydown'>;// → 'click' | 'hover' | 'scroll'3.2 Extract<T, U>: Keep Matching Types
ts
1
2
3
4
type Primitive = string | number | boolean | null;type Truthy = Extract<Primitive, boolean | number | string>;// → string | number | boolean3.3 NonNullable<T>: Remove null/undefined
ts
1
2
3
4
5
type ApiResponse = User | null;function processUser(user: NonNullable<ApiResponse>) {// user is guaranteed to be User}3.4 ReturnType<T>: Get What a Function Returns
ts
1
2
3
4
5
6
function getUser() { return { id: '1', name: 'Alex' };}type UserResult = ReturnType<typeof getUser>;// → { id: string; name: string; }3.5 Parameters<T>: Get Function Args
ts
1
2
3
4
function apiCall(url: string, method: 'GET' | 'POST') { }type ApiParams = Parameters<typeof apiCall>;// → [url: string, method: 'GET' | 'POST']3.6 InstanceType<T>: Class Instance Type
ts
1
2
3
4
5
6
class UserService { getUser() { return { name: 'Alex' }; }}type Service = InstanceType<typeof UserService>;// → UserService4. Combine Utilities: Real-World Patterns
4.1 Patch DTO with Required ID
ts
1
type UserPatch = Partial<Pick<User, 'name' | 'email'>> & { id: string };4.2 Safe API Handler
ts
1
2
type Handler = (req: Request) => Promise<Response>;type HandlerParams = Parameters<Handler>;5. Common Mistakes
ts
1
2
3
4
5
6
7
8
// 1. Manual duplicationinterface UserDTO { id: string; name: string; email: string; }// 2. any for mapsconst cache: any = {};// 3. Wrong Excludetype Bad = Exclude<string | number, string | boolean>;6. Best Practices
ts
1
2
3
4
5
6
7
8
// 1. Reuse with Pick/Omittype UserDTO = Pick<User, 'id' | 'name' | 'email'>;// 2. Record for lookupsconst routes: Record<string, () => void> = {};// 3. Combine for complex typestype UpdatePayload = { id: string } & Partial<User>;7. Utility Types Cheat Sheet
Partial<T>→ optional propsRequired<T>→ all requiredPick<T, K>→ select keysOmit<T, K>→ remove keysRecord<K, T>→ typed mapExclude<T, U>→ remove from unionExtract<T, U>→ keep from unionNonNullable<T>→ remove null/undefinedReturnType<T>→ get function returnParameters<T>→ get function argsInstanceType<T>→ get class instance typeConstructorParameters<T>→ get constructor args
8. Conclusion
Utility types are not shortcuts — they’re leverage.
You’re not just saving lines of code.
You’re eliminating bugs, enforcing contracts, and scaling type safety.
From Partial<Pick<T, K>> to ReturnType<typeof fn>,
every utility is a pattern distilled into a single word.
Master them.
Your types will thank you.
Written by Alex Kim
#TypeScript #UtilityTypes #AdvancedTS #TypeSafety #Exclude #Extract #ReturnType #Pick #Omit #Record #WebDev