компилируется...
Перейти к основному содержанию
Рекомендовать во Вконтакте Рекомендовать в Фейсбуке Рекомендовать в Твиттере

Пишем читаемый typescript код используя перечисления

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

TypeScript (как вы, вероятно, уже знаете) - это сильно типизированный, объектно-ориентированный и компилируемый язык программирования с открытым исходным кодом, разработанный и поддерживаемый командой Microsoft. По сути этот язык просто надстройка над обычным JavaScript со статической типизацией. Он предназначен для разработки крупных и масштабируемых приложений, которые компилируются на JavaScript.

Что такое перечисления?

Вот несколько причин, по которым перечисления очень полезны в TypeScript:

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

Синтаксис перечисления

Перечисления определяются с помощью ключевого слова enum, вот так:

enum Continents {
    North_America,
    South_America,
    Africa,
    Asia,
    Europe,
    Antartica,
    Australia
}

// использование
var region = Continents.Africa;

Типы перечислений TypeScript

Существует три типа перечислений TypeScript, а именно:

  • Числовые перечисления
  • Строковые перечисления
  • Смешанные перечисления

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

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

enum Weekend {
  Saturday,
  Sunday
}

В блоке кода выше, у нас есть перечисление, которое мы называем Weekend. Перечисление имеет три значения, а именно: Saturday и Sunday (суббота и воскресенье). В TypeScript, как и в некоторых других языках, значения перечислений начинаются с нуля и увеличиваются на единицу для каждого члена. Они будут храниться вот так:

Saturday = 0
Sunday = 1

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

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

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

enum Weekend {
  Saturday = 1,
  Sunday
}

Вышеуказанный блок кода будет хранить субботу как 1 и воскресенье как 2. Если мы добавим число к первому члену, мы все равно получим последовательное приращение на один для остальных членов. Тем не менее, у нас есть право диктовать, что мы не хотим последовательный переход, давая им любое числовое значение.

enum Weekend {
  Saturday = 11,
  Sunday = 5
}

Как и другие типы данных в TypeScript, мы можем использовать перечисления в качестве параметров функции или возвращаемые типы, как, например, это:

enum Weekend {
  Saturday = 1,
  Sunday
}

function getDate(Day: string): Weekend {
    if ( Day === 'TGIF') {
        return Weekend.Saturday;
    }
}

let DayType: Weekend = getDate('TGIF');

В блоке кода выше мы объявили Weekend перечисление. Затем мы объявили функцию getDate, которая принимает входной день, возвращающий перечисление Weekend. В этой функции мы проверяем некоторое условие, которое теперь возвращает член перечисления.

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

До сих пор мы смотрели только на перечисления, где значения членов - это числа. В TypeScript члены перечисления также могут быть строковыми значениями. Строковые перечисления жизненно важны и с ними легко работать для удобства чтения во время протоколирования и отладки ошибок из-за их осмысленных строковых значений.

enum Weekend {
  Saturday = 'SATURDAY',
  Sunday = 'SUNDAY'
}

Затем она может быть использована для сравнения строк в таких условных операторах:

enum Weekend {
  Saturday = 'SATURDAY',
  Sunday ='SUNDAY'
}

const value = someString as Weekend;

if (value === Weekend.Saturday || value === Weekend.Sunday){
    console.log('You choose a weekend');
    console.log(value); 
}

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

Смешанные перечисления

TypeScript также позволяет смешивать и строки, и числа, называемые смешанными значениями:

enum Weekend {
  Saturday = 'SATURDAY',
  Sunday = 2
}

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

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

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

enum Weekend {
  Saturday = getDate('TGIF'),
  Sunday = Saturday * 40
}

function getDate(day : string): number {
    if (day === 'TGIF') {
        return 3;
    }
}
Weekend.Saturday; // returns 3
Weekend.Sunday; // returns 120

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

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

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

enum Weekend {
  Saturday,
  Sunday
};

const day = Weekend.Saturday;

При компиляции в JavaScript, во время выполнения выполняется просмотр Weekend и просмотр Weekend.Saturday. Для оптимальной производительности во время выполнения вы можете сделать перечисление константой, например, вот так:

const enum Weekend {
  Saturday,
  Sunday
};

const day = Weekend.Saturday;

Таким образом, JavaScript генерируется при компиляции с константой:

const day = 2;

Обратное отображение

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

enum Weekend {
  Saturday,
  Sunday
}
Weekend.Saturday     
Weekend["Saturday"];  
Weekend[0];

В вышеуказанном блоке кода Weekend.Saturday вернет 0, а Weekend["Saturday"] также вернет 0, но интересно, что в связи с обратным отображением Weekend[0] вернет свое имя члена Weekend[0]: Saturday. Это связано с реверсным отображением. Мы видим простой способ, которым TypeScript интерпретирует обратное отображение командой log:

enum Weekend {
  Saturday,
  Sunday
}
console.log(Weekend);

Если вы запустите это в консоли, вы увидите этот вывод:

{
  0: "Saturday"
  1: "Sunday"
  Saturday: 0
  Sunday: 1
}

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

Когда использовать перечисления TypeScript

Есть места и подходящие случаи использования, где оптимально и очень эффективно использовать перечисления

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

enum EuropeanLanguage {
  Spanish,
  English, 
  Italian
};

let citizen = {
  Name: 'Rodrigo',
  Age: 15,
  Language: EuropeanLanguage.Spanish
};

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

enum Days {
  Sunday = 1,
  Monday,
  Tuesday,
  Wednesday,
  Thursday,
  Friday,
  Saturday
};

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

Когда не использовать перечисления TypeScript

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

  • Когда вы планируете переназначить или изменить значения членов перечисления, перечисления безопасны по типу и, следовательно, возвращают ошибки компиляции при переназначении
  • Перечисления не могут быть использованы в качестве переменных, это вернет ошибки

Комментарии

Пока что нет комментариев, вы можете быть первым.
Войти или Регистрация , чтобы оставлять комментарии.

Лучшие публикации

Популярные теги

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