TypeScript Utility Types: продвинутые техники для чистого кода

Что такое Utility Types

TypeScript поставляется с набором встроенных дженериков, которые упрощают работу с типами. В 2026 году знание продвинутых Utility Types отделяет хорошего TypeScript-разработчика от отличного.

Встроенные Utility Types

Partial<T> — все поля опциональны

interface User {
  id: string;
  name: string;
  email: string;
}

// Для обновления — не все поля обязательны
type UserUpdate = Partial<User>;
// { id?: string; name?: string; email?: string }

async function updateUser(id: string, data: Partial<User>) {
  return db.update(users).set(data).where(eq(users.id, id));
}

Required<T> — все поля обязательны

type RequiredUser = Required<User>;
// Все поля становятся обязательными, даже если были опциональны

Pick<T, K> — выбрать поля

type UserPreview = Pick<User, 'id' | 'name'>;
// { id: string; name: string }

// Полезно для API-ответов без лишних данных
function getUserPreview(user: User): UserPreview {
  return { id: user.id, name: user.name };
}

Omit<T, K> — исключить поля

type UserWithoutPassword = Omit<User, 'password'>;
// Безопасно возвращать клиенту

Record<K, V> — словарь

type ModelCosts = Record<string, number>;
const costs: ModelCosts = {
  'gpt-4o': 0.005,
  'claude-3-5-sonnet': 0.003,
};

Exclude<T, U> и Extract<T, U>

type Tier = 'free' | 'starter' | 'premium';
type PaidTier = Exclude<Tier, 'free'>; // 'starter' | 'premium'
type FreeTier = Extract<Tier, 'free'>; // 'free'

Кастомные Utility Types

DeepPartial — глубокая опциональность

type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

type Config = {
  db: { host: string; port: number };
  api: { key: string; timeout: number };
};

function mergeConfig(base: Config, override: DeepPartial<Config>): Config {
  // ...
}

Nullable<T>

type Nullable<T> = T | null;
type MaybeUser = Nullable<User>;

AsyncReturnType<T>

type AsyncReturnType<T extends (...args: any) => Promise<any>> =
  T extends (...args: any) => Promise<infer R> ? R : any;

async function fetchUser(id: string): Promise<User> { ... }
type FetchedUser = AsyncReturnType<typeof fetchUser>; // User

Readonly Deep

type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

Практические примеры

Типизация API-ответов

type ApiResponse<T> = {
  success: boolean;
  data: T;
  error?: string;
};

type UserResponse = ApiResponse<User>;
type UsersListResponse = ApiResponse<User[]>;

Типизация форм

type FormErrors<T> = Partial<Record<keyof T, string>>;

type LoginForm = { email: string; password: string };
const errors: FormErrors<LoginForm> = { email: 'Неверный формат' };

Заключение

Utility Types — это не просто синтаксический сахар. Они позволяют строить гибкие, переиспользуемые типы без дублирования кода. Освоив их, вы пишете TypeScript, который не ломается при рефакторинге.