Можно ли использовать логическое ветвление в TypeScript типах?

Можно ли использовать логическое ветвление в TypeScript типах?

Да, TypeScript предоставляет мощные инструменты для логического ветвления на уровне системы типов, что позволяет создавать сложные, условные типы и делать статический анализ более выразительным. Это достигается через условные типы (Conditional Types), которые являются аналогом if/else для типов, и другие сопутствующие механизмы.

Основной механизм: условные типы

Условные типы позволяют выбирать один из двух типов на основе условия, которое проверяет совместимость типов. Их синтаксис:

• T extends U ? X : Y, где если T совместим с U, то результатом будет X, иначе — Y.

type IsString<T> = T extends string ? true : false;

type A = IsString<'hello'>; // true
type B = IsString<number>;  // false

Этот механизм — основа логического ветвления в TypeScript. Его можно комбинировать с:

• Дженериками для обобщённых операций.
• Пересечениями (&) и объединениями (|) типов.
• Встроенными утилитами (keyof, infer и др.).

Расширенные возможности для ветвления

1. Инференция (выведение) типов с infer

Ключевое слово infer внутри условных типов позволяет "извлекать" части типов для дальнейшего анализа, что похоже на декомпозицию в логических условиях.

type ExtractReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

type FuncReturn = ExtractReturnType<() => string>; // string
type NotFunc = ExtractReturnType<number>; // never

2. Рекурсивные условные типы

TypeScript поддерживает рекурсивные условные типы, что позволяет обрабатывать вложенные структуры. Это аналогично рекурсивным функциям в логике.

type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;

type Nested = Flatten<Array<Array<number>>>; // number

3. Распределенные условные типы (Distributed Conditional Types)

При работе с объединёнными типами (union types), условные типы автоматически распределяются по каждому элементу объединения, что напоминает применение логического условия к каждому элементу массива.

type ToArray<T> = T extends any ? T[] : never;

type UnionArray = ToArray<string | number>; // string[] | number[]

4. Ветвление на основе свойств объектов

Можно строить комплексные условия, проверяя наличие или тип свойств объектов через комбинацию extends, keyof, и infer.

type HasProperty<T, K extends string> = K extends keyof T ? true : false;

type Obj = { name: string; age: number };
type Check1 = HasProperty<Obj, 'name'>; // true
type Check2 = HasProperty<Obj, 'email'>; // false

Практические примеры логического ветвления

Пример 1: Динамическое определение типа на основе входных данных

Это полезно в библиотеках или API, где тип результата зависит от параметров.

type Response<T> = T extends 'json' ? { data: any } :
                   T extends 'text' ? string :
                   never;

function fetchData<T extends 'json' | 'text'>(format: T): Response<T> {
  // Реализация...
  return null as any;
}

const jsonResponse = fetchData('json'); // Тип: { data: any }
const textResponse = fetchData('text'); // Тип: string

Пример 2: Безопасное извлечение элементов из массива

Условные типы могут гарантировать типобезопасность при работе с массивами переменной длины.

type SecondElement<T extends any[]> = T extends [any, infer Second, ...any[]] ? Second : never;

type Arr1 = SecondElement<[string, number, boolean]>; // number
type Arr2 = SecondElement<[string]>; // never

Пример 3: Формирование сложных валидационных типов

Можно создать тип, который проверяет, является ли переданный тип "валидным" по определённым критериям.

type Validatable = { validate: () => boolean };
type IsValid<T> = T extends Validatable ? (T['validate'] extends () => true ? 'valid' : 'invalid') : 'not validatable';

class TestClass { validate = () => true; }
type Test = IsValid<TestClass>; // 'valid'

Ограничения и лучшие практики

• Производительность: Сложные рекурсивные или распределённые условные типы могут замедлять компиляцию. Рекомендуется использовать их с осторожностью и тестировать на больших проектах.
• Читаемость: Избыточное ветвление может сделать типы трудными для понимания. Документируйте сложные условные типы.
• Совместимость: Всегда проверяйте поддержку в используемой версии TypeScript (условные типы доступны с версии 2.8).

Выводы

• Логическое ветвление в TypeScript типах не только возможно, но и является мощной фичей, которая позволяет писать более типобезопасный и выразительный код.
• Условные типы — это ядро системы ветвления.
• С помощью infer, распределённых типов и рекурсии можно реализовать практически любую логику выбора типов.
• Это особенно полезно при создании утилитарных типов, библиотек или сложных API, где типы должны адаптироваться к условиям.

Таким образом, TypeScript предоставляет полноценный функциональный язык для описания типов с логическим ветвлением, что приближает статическую типизацию к динамической гибкости, сохраняя при этом безопасность.