> Что происходит при объединении полей с конкретными значениями в TypeScript? (TypeScript)

Короткий ответ

При объединении полей с конкретными значениями (literal types) через union (|) TypeScript создаёт union literal type - тип, который может принимать только одно из перечисленных значений. Это позволяет сузить множество возможных значений переменной до конкретного набора, что даёт более точную типизацию, автодополнение и проверку на этапе компиляции.

Подробное объяснение

Union literal types в TypeScript - это комбинация строковых, числовых или булевых литералов, объединённых оператором |. Например, type Direction = 'up' | 'down' | 'left' | 'right'. Такая конструкция создаёт тип, который может быть только одним из указанных значений. Это мощный инструмент для моделирования конечных наборов состояний.

При объединении полей с конкретными значениями TypeScript выполняет следующие действия:

• Создаёт union type, который является супертипом всех перечисленных литералов
• Присваивание любого значения, не входящего в union, вызывает ошибку компиляции
• TypeScript может выполнять type narrowing (сужение типа) через проверки, switch/case или guard functions
• В IDE появляется автодополнение для всех возможных значений

Важно понимать, что union literal types - это не enum, а более лёгкая и гибкая альтернатива. Они не генерируют JavaScript-код и существуют только на уровне типов. При этом они полностью совместимы с discriminated unions, pattern matching и другими продвинутыми возможностями TypeScript.

На практике

Union literal types широко используются для:

• Определения допустимых значений параметров функций (например, 'small' | 'medium' | 'large')
• Моделирования состояний в state management (например, 'idle' | 'loading' | 'success' | 'error')
• Создания discriminated unions для работы с разными формами данных
• Ограничения возможных действий в event-driven архитектуре

При работе с API ответами часто используют union literal types для статусов: type Status = 200 | 201 | 400 | 404 | 500. Это позволяет точно типизировать HTTP-ответы и избежать ошибок при обработке.

Пример кода

TYPESCRIPT
// Базовый union literal type
type Status = 'idle' | 'loading' | 'success' | 'error';

function handleStatus(status: Status): void {
  switch (status) {
    case 'idle':
      console.log('Ожидание');
      break;
    case 'loading':
      console.log('Загрузка...');
      break;
    case 'success':
      console.log('Успешно');
      break;
    case 'error':
      console.log('Ошибка');
      break;
  }
}

// Discriminated union с объектами
type Shape = 
  | { kind: 'circle'; radius: number }
  | { kind: 'square'; side: number }
  | { kind: 'triangle'; base: number; height: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    case 'square':
      return shape.side ** 2;
    case 'triangle':
      return (shape.base * shape.height) / 2;
  }
}

// Union с числовыми литералами
type HttpCode = 200 | 201 | 400 | 404 | 500;

function handleResponse(code: HttpCode): string {
  if (code === 200) return 'OK';
  if (code === 201) return 'Created';
  if (code === 400) return 'Bad Request';
  if (code === 404) return 'Not Found';
  return 'Internal Server Error';
}

Как отвечать на собеседовании

Начни с чёткого определения union literal types и их синтаксиса. Покажи понимание разницы между union types и enum - подчеркни, что union types не генерируют код и более гибкие. Обязательно упомяни type narrowing и discriminated unions как ключевые возможности, которые становятся доступны благодаря union literal types.

Приведи практический пример из реального проекта - например, типизацию состояний загрузки или обработку разных форм данных. Покажи, как union literal types помогают избежать ошибок на этапе компиляции и улучшают читаемость кода.

Хорошо бы упомянуть про exhaustiveness checking - когда switch покрывает все варианты union, TypeScript может гарантировать, что ни один кейс не пропущен. Это особенно полезно при добавлении новых состояний.

Что проверяет интервьюер

Интервьюер оценивает:

• Понимание базового синтаксиса и семантики union literal types
• Умение применять их в реальных сценариях (state management, API, discriminated unions)
• Знание продвинутых возможностей: type narrowing, exhaustiveness checking, совместимость с generics
• Способность объяснить trade-off между union types и enum, а также когда что использовать
• Понимание, что union literal types - это исключительно compile-time конструкция

На senior уровне ожидается, что кандидат не просто знает синтаксис, но и может объяснить, как union literal types влияют на архитектуру приложения, безопасность типов и поддерживаемость кода.

Типичные ошибки

• Путаница между union types и intersection types (| vs &)
• Попытка использовать union literal types для динамических значений, которые не известны на этапе компиляции
• Забывание про type narrowing при работе с union - попытка обратиться к свойству, которое есть не у всех вариантов
• Использование enum там, где достаточно union literal types (enum генерирует лишний код)
• Неправильное понимание discriminated unions - забывают про общее поле-дискриминатор
• Игнорирование exhaustiveness checking - не покрывают все варианты в switch