Перечислимый тип TypeScript — это удобный способ упаковки связанных значений с четким значением.

Перечисление или перечисляемый тип — это структура данных, позволяющая определить набор именованных значений.

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

Создание перечисления

Перечисления обычно представляют собой фиксированное количество вариантов для данного значения. Например, перечисление, представляющее основные цвета, может иметь фиксированные значения для красного, желтого и синего.

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

Вы можете создать перечисление в

instagram viewer
язык TypeScript используя перечисление ключевое слово. За ним следует имя перечисления и пара фигурных скобок ({}), содержащий элементы перечисления. Общее соглашение об именах JavaScript утверждает, что имена перечислений должны начинаться с заглавной буквы.

перечисление Направление {
 Вверх,
 Вниз,
 Левый,
 Верно
}

В этом примере используется перечисление под названием Направление. В перечислении есть член, представляющий каждое направление: вверх, вниз, влево и вправо.

Поскольку в этом коде не указано значение для каждого из ключей, TypeScript автоматически назначит значения. Первый член, Up, будет иметь значение 0. Каждый из оставшихся членов будет иметь значение на 1 больше, чем у предыдущего члена. Вы можете явно объявить это, если вам трудно запомнить:

перечисление Направление {
 Вверх = 0,
 Вниз = 1,
 Слева = 2,
 Вправо = 3,
}

Или вы можете явно объявить разные значения, оставив необъявленные значения для продолжения увеличения, как и раньше:

перечисление Положение дел {
 Активный = 9,
 Неактивный, // 10
}

В этом примере неактивный элемент имеет значение 10. Это поведение применяется к перечислениям, которые имеют только числовые значения, а не к перечислениям со строковыми или разнородными элементами.

Различные типы Enum

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

Строковые перечисления

Строковое перечисление — это перечисление, все члены которого являются строками. В отличие от числовых перечислений, где значения присваиваются автоматически, вы должны инициализировать каждый член строкой:

перечисление Первичные цвета {
 Красный = "КРАСНЫЙ",
 Желтый = "ЖЕЛТЫЙ",
 Синий = "СИНИЙ"
}

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

Гетерогенные перечисления

Гетерогенные перечисления — это перечисления, которые содержат как числовые, так и строковые элементы. Например:

перечисление Результат {
 Успех = "УСПЕХ",
 Ошибка = 0
}

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

Вычисляемые и константные члены Enum

Каждый элемент перечисления имеет значение, которое может быть либо постоянным, либо вычисляемым.

Постоянные члены перечисления

Член перечисления является постоянным, если он удовлетворяет любому из следующих условий.

  1. Это первый член перечисления и не имеет инициализатора.
  2. У него нет инициализатора, а предыдущий член перечисления был числовой константой.
  3. Он инициализируется константным выражением перечисления.

Согласно документации TypeScript, постоянное выражение перечисления — это подмножество выражений TypeScript, которые можно полностью оценить во время компиляции. Например, строка или числовой литерал.

Например, все члены перечислений в приведенном ниже блоке кода являются постоянными:

// ДЕЛО 1
перечисление Направление {
 Вверх,
 Вниз,
 Левый,
 Верно
}
// СЛУЧАЙ 2
перечисление будний день {
 Понедельник = 1,
 Вторник,
 Среда,
 Четверг,
 Пятница
}
// СЛУЧАЙ 3
перечисление Время года {
 Весна = "ВЕСНА",
 Лето = "ЛЕТО",
 Осень = "ОСЕНЬ",
 Зима = "ЗИМА"
}

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

Например, вот транспилированная версия перечисления Season:

вар Время года;
(функция (Время года) {
 Время года["Весна"] = "ВЕСНА";
 Время года["Лето"] = "ЛЕТО";
 Время года["Осень"] = "ОСЕНЬ";
 Время года["Зима"] = "ЗИМА";
})(Сезон || (Сезон = {}));

Вычисляемые члены перечисления

Вы можете использовать вычисляемые элементы перечисления для присвоения значений членам перечисления на основе выражений или других динамических вычислений. Например:

перечисление Размер {
 Маленький = 1,
 Средний = вычислить размер (12),
 Большой = вычислить размер (5)
}
функциявычислить размер(ценить: число): число{
возвращаться ценить * 5;
}
консоль.log (Размер. Большой)

Размер enum состоит из трех членов: Маленький, Середина, и Большой. Он явно присваивает значение 1 элементу Small. Середина и Большой участники используют функцию вычислить размер для вычисления их значений во время выполнения.

При работе с вычисляемыми элементами перечисления важно помнить, что значения неизвестны до времени выполнения. Это может привести к большей сложности и потенциалу ошибки времени выполнения по сравнению с членами перечисления с постоянными значениями.

Например:

вар Размер;
(функция (Размер) {
 Размер[Размер["Маленький"] = 1] = "Маленький";
 Размер[Размер["Середина"] = вычислить размер (12)] = "Середина";
 Размер[Размер["Большой"] = вычислить размер (5)] = "Большой";
})(Размер || (Размер = {}));
консоль.бревно(Размер.Большой)

Приведенный выше блок кода представляет собой транспилированную версию Размер перечисление Обратите внимание, что TypeScript не включает в код JavaScript значения, возвращаемые функцией calculateSize(). Вместо этого он включает исходный вызов функции, чтобы JavaScript определял значения во время выполнения.

Доступ к значениям перечисления

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

Например:

перечисление Направление {
 Вверх = 0,
 Вниз = 1,
 Слева = 2,
 Вправо = 3,
}
консоль.log(Направление. Левый) // 2

Обратное отображение числовых перечислений

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

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

Например:

перечисление Направление {
 Вверх = 1,
 Вниз,
 Левый,
 Верно
}
функцияgetDirectionName(значение направления: число): нить{
// Обратное отображение
константа имянаправления = Направление[значениенаправления];
возвращаться направлениеНазвание;
}
консоль.log(getDirectionName(1)); // "Вверх"
консоль.log(getDirectionName(3)); // "Левый"

Этот getDirectionName Функция выполняет обратное сопоставление, обращаясь к имени члена перечисления, используя его значение в качестве индекса. Функция принимает направлениезначение в качестве аргумента и извлекает соответствующее имя члена перечисления, используя Направление[directionValue].

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

Есть много приложений Enums

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

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