Руководство по перечислению TypeScript

Руководство по перечислению TypeScript Изучение

Перечисления (или перечисления) — это поддерживаемый тип данных в TypeScript. Перечисления используются в большинстве объектно-ориентированных языков программирования, таких как Java и C #, а теперь доступны и в TypeScript. Это одна из немногих функций TypeScript, которая не является расширением JavaScript на уровне типов. Перечисления позволяют определять набор именованных констант. Их использование упрощает документирование намерений или создание набора отдельных случаев. Сегодня мы рассмотрим основы перечислений TypeScript, а также варианты использования, различные типы перечислений и следующие шаги для вашего обучения.

Что такое enum в Typescript?

Перечисления TypeScript позволяют определять набор именованных констант. Их использование может упростить документирование намерений или создание набора отдельных случаев. Многие языки программирования, такие как C, C # и Java, имеют enumтип данных, а JavaScript — нет. Однако TypeScript делает. TypeScript имеет как числовые, так и строковые перечисления.

Синтаксис перечислений следующий:

enum States {
    Oregon,
    Washington,
    Idaho,
    Montana,
    Wyoming
}
// usage
var region = States.Washington;

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

Зачем использовать перечисления в TypeScript?

Перечисления — отличный способ организовать ваш код в TypeScript. Давайте посмотрим на некоторые плюсы:

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

Перечисления против альтернатив

Хотя использование перечислений TypeScript дает множество преимуществ, в некоторых случаях вам не следует их использовать, например:

  • Переназначение или изменение значений членов перечисления: перечисления являются типобезопасными и будут возвращать ошибки компиляции при переназначении
  • Запись динамических значений : перечисления подходят для конечных элементов и помогают создать систему констант, определяемую пользователем.
  • Использование переменных : перечисления нельзя использовать в качестве переменных, и это приведет к ошибкам.
Читайте также:  Интернет вещей и домашняя автоматизация: что ждет в будущем?

Теперь давайте углубимся в некоторые типы перечислений.

Числовые перечисления

Числовые перечисления хранят строковые значения как числа. Их можно определить с помощью enumключевого слова. Допустим, вы хотите хранить набор разных типов автомобилей. В следующем примере показано числовое перечисление в TypeScript:

enum CarType {
    Honda,
    Toyota,
    Subaru,
    Hyundai
}

Значение перечисления CarTypeимеет четыре значения: Honda, Toyota, Subaru и Hyundai. Значения перечисления начинаются с нуля и увеличиваются на единицу для каждого члена, что будет выглядеть примерно так:

Honda = 0
Toyota = 1
Subaru = 2
Hyundai = 3

При желании вы можете самостоятельно инициализировать первое числовое значение следующим образом:

enum CarType {
    Honda = 1,
    Toyota,
    Subaru,
    Hyundai
}

В приведенном выше примере мы инициализировали первый член Hondaчисловым значением, равным единице. Остальные числа будут увеличены на единицу.

Примечание : нет необходимости назначать последовательные значения вашим членам перечисления. Вы можете присвоить им любые значения, какие захотите.

Перечисления строк

Перечисления строк аналогичны числовым перечислениям, но их значения перечисления инициализируются строковыми значениями вместо числовых значений. Строковые перечисления лучше читаются, чем числовые, что упрощает отладку ваших программ.

В следующем примере используется та же информация, что и в примере числового перечисления, но она представлена ​​в виде строкового перечисления:

enum CarType {
    Honda = «HONDA»,
    Toyota = «TOYOTA»,
    Subaru = «SUBARU»,
    Hyundai = «HYUNDAI»
}
// Access String Enum
CarType.Toyota; //returns TOYOTA
CarType[‘Honda’]; //returns HONDA

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

Примечание. Строковые значения перечисления необходимо инициализировать индивидуально.

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

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

enum BooleanHeterogeneousEnum {
    Yes = 0,
    No = «NO»,
}

Обратное отображение с перечислениями

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

enum CarType {
    Honda = 1,
    Toyota,
    Subaru,
    Hyundai
}
CarType.Subaru; // returns 3
CarType[«Subaru»]; // returns 3
CarType[3]; // returns Subaru

CarType[3]возвращает имя своего члена «Subaru» из-за обратного отображения. Давайте посмотрим на другой пример:

enum CarType {
    Honda = 1,
    Toyota,
    Subaru,
    Hyundai
}
console.log(CarType)

В консоли браузера вы увидите следующий вывод:

{
    ‘1’: ‘Honda’,
    ‘2’: ‘Toyota’,
    ‘3’: ‘Subaru’,
    ‘4’: ‘Hyundai’,
    Honda: 1,
    Toyota: 2,
    Subaru: 3,
    Hyundai: 4
}

Каждое значение перечисления появляется два раза во внутреннем хранящемся объекте перечисления.

Перечисления констант

Вы можете использовать константные перечисления для повышения производительности ваших числовых перечислений. Они определяются с помощью constмодификатора:

const enum Enum {
    X = 1
    Y = X * 2,
}

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

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

Значение члена перечисления может быть постоянным или вычисленным значением. Следующий пример включает вычисленные значения:

enum CarType {
    Honda = 1,
    Toyota = getCarTypeCode(‘toyota’),
    Subaru = Toyota * 3,
    Hyundai = 10
}
function getCarTypeCode(carName: string): number {
    if (carName === ‘toyota’) {
        return 5;
    }
}
CarType.Toyota; // returns 5
CarType.Subaru; // returns 15

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

enum CarType {
    Toyota = getCarTypeCode(‘toyota’),
    Honda, // Error: Enum member must have initializer
    Subaru,
    Hyundai = Toyota * 3,
}

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

enum CarType {
    Honda,
    Hyundai,
    Toyota = getCarTypeCode(‘toyota’),
    Subaru = Toyota * 3

Что изучать дальше

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

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

  • Строгие типы
  • Общие функции
  • Сопоставленные типы
  • И многое другое
Оцените статью
bestprogrammer.ru
Добавить комментарий