TypeScript: условные типы

Условные типы — одна из самых мощных возможностей системы типов TypeScript.

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

Условные типы делают определения типов более гибкими и лежат в основе реализации продвинутых утилитных типов.


Диаграмма SVG: поток условного типа Background Title How Conditional Types Work Syntax Explanation Conditional Type Syntax T extends U ? X : Y Arrow Execution Flow Execution Flow Check whether T can be assigned to U → Yes → X | No → Y Example Area Example Analysis Example 1 Example 1 IsString<string> string extends string? ✓ → true Example 2 Example 2 IsString<number> number extends string? ✗ → false Example 3 Example 3 ReturnType<fn> fn extends (...args) → R (inferred return type) Arrow Marker

Зачем нужны условные типы?

В реальной разработке на TypeScript нам часто нужно возвращать разные типы в зависимости от разных входных типов.

Например, функция может принимать параметры типа string или number, и нам нужно возвращать разные типы результата в зависимости от типа параметра.

Условные типы предоставляют возможность выполнять логические проверки на уровне типов, делая определения типов более гибкими и мощными.

Пояснение концепции:Синтаксис условных типов:T extends U ? X : YЕсли тип T может быть присвоен типу U, вернуть тип X; в противном случае вернуть тип Y.


Базовый синтаксис

Условные типы используют синтаксис тернарного выражения для выполнения условных проверок на уровне типов.

Это позволяет нам динамически вычислять возвращаемый тип на основе входного типа.

Пример

// Синтаксис условного типа: T extends U ? X : Y
// Если T — строковый тип, вернуть true; в противном случае вернуть false
type IsString<T> = T extends string ? true : false;

// Использование условного типа
// string extends string — true, поэтому тип A равен true
type A = IsString<string>;
// number extends string — false, поэтому тип B равен false
type B = IsString<number>;

// Использование этих типов
var a: A = true;
var b: B = false;

console.log("Является ли string строкой?: " + a);
console.log("Является ли number строкой?: " + b);

Вывод:

string 是字符串?: true
number 是字符串?: false

Пояснение:Условные типы автоматически вычисляются во время проверки типов, чтобы получить конкретные типы.


Практическое применение: фильтрация типов

Одно из самых распространённых применений условных типов — фильтрация типов.

Например, можно создать тип, исключающий null и undefined.

Пример

// Реализация NonNullable с помощью условного типа
// Если T равен null или undefined, вернуть never (пустой тип); иначе вернуть сам T
type NonNullable<T> = T extends null | undefined ? never : T;

// Использование типа NonNullable
// string не является null/undefined, поэтому тип — string
type A = NonNullable<string>;
// null — это null/undefined, поэтому тип — never
type B = NonNullable<null>;
// undefined — это null/undefined, поэтому тип — never
type C = NonNullable<undefined>;

// Проверка типа
var a: A = "hello";
console.log("Non-null: " + a);

Вывод:

非空: hello

Тип never:never представляет тип, который никогда не существует. Когда условие не выполняется, TypeScript использует never для обозначения "недоступного" типа.


Вывод типов: ключевое слово infer

Ключевое слово infer — одна из самых мощных возможностей условных типов.

Оно позволяет "извлекать" или "выводить" определённые части типа из типа.

Пример

// Использование infer для вывода возвращаемого типа функции
// Если T — функциональный тип, вернуть выведенный возвращаемый тип R; иначе вернуть never
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

// Определить функцию, возвращающую объект пользователя
function getUser() {
    return { name: "Alice" };
}

// Определите функцию, возвращающую число
function getNumber() {
    return 42;
}

// Использование ReturnType для получения типа возвращаемого значения функции
// Выводится как { name: string }
type R1 = ReturnType<typeof getUser>;
// Выводится как number
type R2 = ReturnType<typeof getNumber>;

// Использование выведенных типов
var r1: R1 = { name: "Bob" };
var r2: R2 = 100;

console.log("Пользователь: " + JSON.stringify(r1));
console.log("Число: " + r2);

Вывод:

User: {"name":"Bob"}
数字: 100

Роль infer:infer подобен "переменной" в системе типов; он может захватить определённую часть типа и использовать её в результирующем типе.


Распределительные условные типы

Когда generic-параметр условного типа является union-типом, "распределение" применяется автоматически.

То есть условие применяется к каждому члену union-типа отдельно, а результаты затем объединяются.

Пример

// ToArray преобразует тип T в тип массива
// Когда T является union-типом, каждый тип автоматически распределяется
type ToArray<T> = T extends any ? T[] : never;

// Union-типы автоматически распределяются
// string | number распределяется как: ToArray<string> | ToArray<number>
// то есть string[] | number[]
type StrOrNum = ToArray<string | number>;

// Ему можно присвоить string[] или number[]
var arr: StrOrNum = ["hello"];
// Ему также можно присвоить число
arr = 42;

console.log("Массив: " + arr);

Вывод:

数组: 42

Механизм распределения:Распределительное поведение условных типов включается автоматически. Чтобы отключить распределение, можно использовать квадратные скобки:[T] extends U。


Комбинирование условных типов с отображаемыми типами

Условные типы можно комбинировать с отображаемыми типами, чтобы создавать мощные утилиты преобразования типов.

Эта комбинация лежит в основе реализации встроенных служебных типов TypeScript.

Пример

// Определяем интерфейс пользователя
interface User {
    // ID пользователя
    id: number;
    // Имя пользователя
    name: string;
    // Электронная почта пользователя
    email: string;
}

// Реализуйте Partial с помощью отображаемых типов и условных типов
// Перебрать все свойства T и добавить модификатор необязательности ?
type Partial<T> = {
    [P in keyof T]?: T[P];
};

// Реализовать Required с помощью отображаемых и условных типов
// Перебрать все свойства T и удалить модификатор необязательности -?
type Required<T> = {
    [P in keyof T]-?: T[P];
};

// Использование Partial: все свойства становятся необязательными
var partial: Partial<User> = { name: "Alice" };

// Использование Required: сделать свойства Partial<User> обязательными
// Сначала должен существовать тип Partial<User>
type RequiredUser = Required<Partial<User>>;
var required: RequiredUser = { name: "Bob", id: 1 };

console.log("Необязательно: " + JSON.stringify(partial));
console.log("Обязательно: " + JSON.stringify(required));

Вывод:

可选: {"name":"Alice"}
必填: {"name":"Bob","id":1}

Комбинированное использование:Сочетание условных типов и отображаемых типов может реализовать различные сложные преобразования типов, такие как встроенные служебные типы, например Partial, Required и Readonly.


Продвинутый пример: проверка типов

Условные типы также можно использовать для реализации более сложных проверок типов.

Ниже приведены некоторые полезные примеры проверки типов в реальной разработке.

Пример

// Проверить, является ли тип any
// Пересечение any с любым типом даёт any, поэтому 0 extends any истинно
type IsAny<T> = 0 extends (1 & T) ? true : false;

// Тестирование IsAny
// any — это особый тип; пересечение его с любым типом возвращает any
type A = IsAny<any>;       // true
// string не является any
type B = IsAny<string>;    // false

console.log("Является ли any any?: " + A);
console.log("Является ли string any?: " + B);

// Проверка, можно ли присвоить тип
// Возвращает true, если T можно присвоить U, иначе возвращает false
type IsAssignableTo<T, U> = T extends U ? true : false;

// Проверка присваиваемости типов
// string можно присвоить any, поэтому возвращается true
type CanAssign = IsAssignableTo<string, any>;
console.log("string можно присвоить any?: " + CanAssign);

Результат выполнения:

any 是 any?: true
string 是 any?: true

Примечание:any — самый "снисходительный" тип в TypeScript. Его можно присвоить любому типу, и он может принимать присваивания от любого типа.


Примечания

  • Ленивое вычисление:Условные типы вычисляются лениво; они вычисляются только тогда, когда используются конкретные типы.
  • Дистрибутивное свойство:Типы-объединения автоматически запускают механизм распределения условных типов.
  • infer можно использовать только в условиях extends:Это единственное место, где может появиться infer.
  • Комбинирование с отображаемыми типами:Комбинирование условных типов с отображаемыми типами позволяет создавать мощные служебные типы.

Продвинутое:Многие встроенные служебные типы TypeScript (такие как Partial, Required, Extract) реализованы с помощью условных типов.


Итог

Условные типы — одна из самых мощных возможностей системы типов TypeScript.

  • Базовый синтаксис:T extends U ? X : Y
  • Ключевое слово infer:Выводить определённые части из типа.
  • Дистрибутивное свойство:Типы-объединения автоматически распределяются.
  • Сценарии применения:Фильтрация типов, вывод типов, проверка типов.
  • Служебные типы:Большинство встроенных служебных типов реализовано на основе условных типов.

Лучшие практики:Освоение условных типов позволяет писать более гибкий и типобезопасный код.


Другие расширения