Enum в C# и некоторые его особенности
За свою непродолжительную карьеру C# разработчика я успел поверхностно погрузиться во многие аспекты этого, без преувеличения, прекрасного языка. Наиболее любопытной из них для меня является такая, с первого взгляда, простая вещь, как перечисления или же enum, о коей я попытаюсь рассказать в этой статье.
Что же такое enum и на кой он вообще нужен?
Представим что нам необходимо определить такое свойство класса как цвет. Как же нам решить эту проблему?
Мы можем сделать это через строковую переменную:
public class ClassWithString < public ClassWithString(string color) < Color = color; >public string Color < get; >public bool IsDefinedColor(string otherColor) => Color.Equals(otherColor); >
var redClass = new ClassWithString(«Red»); var check = redClass.IsDefinedColor(«Red»); //true var secondCheck = redClass.IsDefinedColor(«Blue»); //false
В результате выполнения кода значение check будет равно true, а secondCheck будет равно false. Вроде бы задача решена, в прод.
Уроки C# (C sharp) | #24 — Перечисления (enum)
Но человек существо не идеальное, и может случиться такое, что в метод будет передано не Red, а red или rad. Вроде-бы человек может догадаться что было ему сказано, но машина прямолинейна и догадываться не будет. В результате некорректного ввода метод будет возвращать false, хотя мы ожидаем true:
var redClass = new ClassWithString(«Red»); var check = redClass.IsDefinedColor(«Red»); //true var secondCheck = redClass.IsDefinedColor(«blue»); //false var thirdCheck = redClass.IsDefinedColor(«red»); //false var fourthCheck = redClass.IsDefinedColor(«rad»); //false
Конечно первый вид опечатки можно исправить добавлением в Equals дополнительного параметра StringComparison.OrdinalIgnoreCase. Но этого не сделать при второй опечатке. Значит строки нам не особо подходят.
Color.Equals(otherColor, StringComparison.OrdinalIgnoreCase);
Иным решением может быть хранение значений в численной переменной, заранее определив какому числу какое состояние соответствует.
//0 — red //1 — blue public class ClassWithInt < public ClassWithInt(int color) < Color = color; >public int Color < get; >public bool IsDefinedColor(int otherColor) => Color.Equals(otherColor); >
Вроде-бы проблема решена: теперь никто не опечатается при вводе кода цвета. Но здесь всплывает другая проблема: человек не машина, и работать со словами ему на порядок проще чем с числами.
Постоянно помнить, что 0 — это красный, а 1 — это синий, никакой памяти не напасёшься. А если человек поменяет проект и под номером 0 будет белый, а под 1 черный? Ерунда какая-то.
И тут нам на помощь приходит генная инженерия, позволяющая нарушить базовые законы колдовства и естества. Мы можем скрестить числа и строки. После столь противоестественного действия мы и получим любимый мною enum.
Enum-ом в базовом понимании называют некий список возможных, заранее определенных, именованных значений. Нужен этот список для того, чтобы упростить работу разработчику в оперировании некими состояниями. Решим нашу задачу с применением enum.
Перечисляемый тип enum С++. Изучение С++ для начинающих. Урок #124
public class ClassWithEnum < public ClassWithEnum(Colors color) < Color = color; >public Colors Color < get; >public bool IsDefinedColor(Colors otherColor) => Color.Equals(otherColor); public enum Colors < Red, Blue >>
Как можно увидеть внизу нашего класса мы определили тот самый enum и сказали, что он может принимать 2 значения: Red и Blue. Теперь повторим вызов из примера со строками:
var redClass = new ClassWithEnum(ClassWithEnum.Colors.Red); var check = redClass.IsDefinedColor(ClassWithEnum.Colors.Red); //true var secondCheck = redClass.IsDefinedColor(ClassWithEnum.Colors.Blue); //false
Как можно заметить, всё понятно, ясно, чЁтКо. А теперь попытаемся опечататься:
var redClass = new ClassWithEnum(ClassWithEnum.Colors.Red); var check = redClass.IsDefinedColor(ClassWithEnum.Colors.Red); //true var secondCheck = redClass.IsDefinedColor(ClassWithEnum.Colors.Blue); //false var thirdCheck = redClass.IsDefinedColor(ClassWithEnum.Colors.red); //Ошибка ввода var fourthCheck = redClass.IsDefinedColor(ClassWithEnum.Colors.rad); //Ошибка ввода
Редактор кода говорит, что я дурачок и не умею правильно писать слова. А это значит, что я могу заметить ошибку ещё до сборки и гарантированно её замечу во время сборки. Спасибо, добрый блокнот.
В принципе на этом можно было бы и закончить статью, но тогда какой в ней смысл, если это повествование можно было сократить раза в четыре. Непорядок! Поэтому, после базового пояснения что такое enum и нафига он нужен будут настоящие сенсации. Внимание, барабанная дробь.
Enum это число!1!1!1
Как было сказано выше enum — это, по сути, плод запретной любви строки и числа. От строки, как было показано, опять же, выше enum получил отличную человекочитаемость. От числа enum получил устойчивость к неправильному вводу. Но, помимо этого, от числа enum получил и внутренности.
По сути enum это обыкновенное число с табличкой. В примере выше это было не явно потому, что в списке были только имена, но не было чисел. Это не совсем правильный, хотя и рабочий по причине автопроставления чисел, подход к определению enum-а. Более правильным будет следующий подход:
public enum Colors
Из того, что enum — это число с бейджиком, следует несколько особенностей:
- Возможность хранения нескольких булевых свойств в битовых флагах
- Возможность приведения числа к enum.
- Особенное приведение одного enum-а к другому.
Разберем эти особенности:
Битовые флаги
Предположим мы имеем некий объект, обладающий рядом булевых свойств. Мы, несомненно, можем описать их в виде нескольких самостоятельных полей типа bool. Данный подход является вполне приемлемым:
public class ClassWithBools < public ConditionsBools Conditions < get; set; >public class ConditionsBools < public bool HasSomething < get; set; >public bool DoSomething < get; set; >public bool HasAnother < get; set; >public bool DoAnother < get; set; >> >
Однако, есть иной способ определить эти атрибуты. Для этого мы можем использовать такую надстройку над enum-ом, как битовые флаги. Подобная конструкция представляет из себя обыкновенное enum-ом, обладающее атрибутом [Flags] и числовыми значениями, представляющими из себя степени двойки:
public class ClassWithFlags < public ConditionsFlags Conditions < get; set; >[Flags] public enum ConditionsFlags < HasSomething = 1 >
Как же работать с бинарным флагом? В случае использования отдельных булевых переменных всё достаточно очевидно: обращайся к конкретной переменной и читай или же присваивай значение. Но в случае же работы битовыми флагами приходится использовать базовые двоичные операции: конъюнкция (И, classWithFlags.Conditions |= ConditionsFlags.DoAnother; //Присвоение значения var hasClassDoAnother = (classWithFlags.Conditions //Чтение значения hasClassDoAnother = classWithFlags.Conditions.HasFlag(ConditionsFlags.DoAnother); //Более привычное чтение
Как можно увидеть, работа с битовыми флагами является несколько нестандартной. Помимо этого неудобства, битовый флаг подразумевает, что состояние всегда определено и равно либо true, либо false, и не может быть равно null. Данная особенность может являться недостатком, поскольку порой постановка задачи может подразумевать, что состояние может быть неизвестно.
Битовый флаг является достаточно специфичным типом данных. Его использование вместо структуры, обладающей булевыми переменными, зачастую является спорным, но иногда вполне оправданным. Одним из неочевидных преимуществ использования флагов является следующий момент: в случае использования битовых флагов нет необходимости обновлять структуру базы данных каждый раз, как появляется новое свойство, поскольку в базе данных подобные флаги зачастую хранятся в виде чисел.
Приведение числа к enum
В ходе решения некой задачи нам может понадобиться на время расширить допустимый диапазон значений enum, но вот незадача, мы не хотим чтобы дополнительные значения были видны извне написанного нами кода, или же мы не имеем доступа к редактированию enum по причине того, что он не наш и поставляется нам сторонней библиотекой. Как же быть, спросите вы. А всё легко и просто, следите за руками.
public class ClassWithEnumCast < private const Colors TempColor = (Colors)int.MaxValue; private readonly Colors[] _colorsOrder = < Colors.Red, TempColor, Colors.Black, Colors.White, Colors.Blue >; public IEnumerable GetOrder(Colors color) => _colorsOrder.Select(x => x is TempColor ? color : x ).Distinct(); public enum Colors < Red = 0, Blue = 1, White = 3, Black = 4 >>
В представленном коде решается задача кастомной сортировки цветов с учетом того, что на второй позиции должен находиться передаваемый в функцию цвет. Для определения плейсхолдера я использую возможность приведения числа к enum. Данная константа является неименованным enum-ом, который, в принципе, может существовать и за пределами этого класса. В случае необходимости обращения к нему необходимо лишь снова привести исходное число к данному enum-у.
В случае же, если мы приведем уже использованное в перечислении число, в переменной будет находиться соответствующее значение:
var color = (Colors)1; //Blue var undefinedColor = (Colors)5; //5
Приведение одного enum к другому
Представим, что нам необходимо привести один enum к другому, например при маппинге одной структуры к другой. Как же поведет себя enum? Определим пару enum-ов и попробуем это сделать:
public enum Colors1 < Red = 0, Blue = 1 >public enum Colors2
В представленном примере мы создали два enum-а, один из которых обладает всеми значениями второго, но со смещенной из-за дополнительного значения нумерацией. Теперь попробуем привести первый enum ко второму:
var color = (Colors2)Colors1.Red; //White
Но как же так, вроде же мы должны были получить значение Red, но получили White? Всё дело в том, что enum, как было сказано выше, является лишь именованным числом и приведение происходит именно по числовому значению. В случае необходимости подобного приведения потребуется написать дополнительный хелпер или явно описать каст через implicit/explicit.
public static Colors2 Cast(this Colors1 color) => color switch < Colors1.Red =>Colors2.Red, Colors1.Blue => Colors2.Blue, _ => Colors2.White >;
Бонусный контент
Подобный пример был создан на основе комментария с просторов Метанита. Предположим мы решим в край упороться и написать следующий enum (так делать не надо, пнятнеько):
enum Colors
А затем посмотреть как он будет себя вести:
var color1 = Colors.Black; //White var color2 = Colors.Red; //Blue
Что же за магия происходит в этом примере?
Поскольку у значения White явно не указано число, ему автоматически предоставляется число предыдущего значения +1, а поскольку это значение первое и перед ним ничего нет ему будет проставлено значение 0. Далее мы явно указываем для Black значение 0, что дублирует уже предоставленное значение для White. А поскольку White определено до Black, то и при обращении по значению 0 мы получим именно White.
В случае же color2, из-за описанной выше логики автопроставления чисел, значению Red было проставлено число 2+1=3. А при получении значения по числу вернулось первое в списке с таким числом.
Такие вот дела, ребята. А на сегодня всё.
Источник: habr.com
Enum c что это за программа
Кроме примитивных типов данных в языке программирования C# есть такой тип как enum или перечисление . Перечисления представляют набор логически связанных констант.
Объявление перечисления происходит с помощью оператора enum :
enum название_перечисления < // значения перечисления значение1, значение2, . значениеN >
После оператора enum идет название перечисления. И затем в фигурных скобках через запятую перечисляются константы перечисления.
Определим простейшее перечисление:
enum DayTime
Здесь определено перечисление DayTime, которое имеет четыре значения: Morning, Afternoon, Evening и Night
Каждое перечисление фактически определяет новый тип данных, с помощью которых мы также, как и с помощью любого другого типа, можем определять переменные, константы, параметры методов и т.д. В качестве значения переменной, константы и параметра метода, которые представляют перечисление, должна выступать одна из констант этого перечисления, например:
const DayTime dayTime = DayTime.Morning;
Далее в программе мы можем использовать подобные переменные/константы/параметры как и любые другие:
DayTime dayTime = DayTime.Morning; if(dayTime == DayTime.Morning) Console.WriteLine(«Доброе утро»); else Console.WriteLine(«Привет»); enum DayTime
Хранение состояния
Зачастую переменная перечисления выступает в качестве хранилища состояния, в зависимости от которого производятся некоторые действия:
DayTime now = DayTime.Evening; PrintMessage(now); // Добрый вечер PrintMessage(DayTime.Afternoon); // Добрый день PrintMessage(DayTime.Night); // Доброй ночи void PrintMessage(DayTime dayTime) < switch (dayTime) < case DayTime.Morning: Console.WriteLine(«Доброе утро»); break; case DayTime.Afternoon: Console.WriteLine(«Добрый день»); break; case DayTime.Evening: Console.WriteLine(«Добрый вечер»); break; case DayTime.Night: Console.WriteLine(«Доброй ночи»); break; >> enum DayTime
Здесь метод PrintMessage() в качестве параметра принимает значение типа перечисления DayTime и зависимости от этого значения выводит определенное приведение.
DoOperation(10, 5, Operation.Add); // 15 DoOperation(10, 5, Operation.Subtract); // 5 DoOperation(10, 5, Operation.Multiply); // 50 DoOperation(10, 5, Operation.Divide); // 2 void DoOperation(double x, double y, Operation op) < double result = op switch < Operation.Add =>x + y, Operation.Subtract => x — y, Operation.Multiply => x * y, Operation.Divide => x / y >; Console.WriteLine(result); > enum Operation
Здесь определено перечисление Operation, которое представляет арифметические операции. Каждый тип операций определен в виде одной из констант перечисления. И также определен метод DoOperation() , который в качестве параметров принимает два числа и тип операции в виде константы перечисления и в зависимости от этого типа возвращает из конструкции switch результат определенной операции.
Тип и значения констант перечисления
Константы перечисления могут иметь тип. Тип указывается после названия перечисления через двоеточие:
enum Time : byte
Тип перечисления обязательно должен представлять целочисленный тип (byte, sbyte, short, ushort, int, uint, long, ulong). Если тип явным образом не указан, то по умолчанию используется тип int .
Тип влияет на значения, которые могут иметь константы. По умолчанию каждому элементу перечисления присваивается целочисленное значение, причем первый элемент будет иметь значение 0, второй — 1 и так далее. Например, возьмем выше определенное DayTime:
DayTime now = DayTime.Morning; Console.WriteLine((int) now); // 0 Console.WriteLine((int) DayTime.Night); // 3 enum DayTime
Мы можем использовать операцию приведения, чтобы получить целочисленное значение константы перечисления:
(int) DayTime.Night // 3
В то же время, несмотря на то, что каждая константа сопоставляется с определенным числом, мы НЕ можем присвоить ей числовое значение:
DayTime now = 2; // ! Ошибка
Можно также явным образом указать значения элементов, либо указав значение первого элемента:
enum DayTime < Morning = 3, // каждый следующий элемент по умолчанию увеличивается на единицу Afternoon, // этот элемент равен 4 Evening, // 5 Night // 6 >
Но можно и для всех элементов явным образом указать значения:
enum DayTime
При этом константы перечисления могут иметь одинаковые значения, либо даже можно присваивать одной константе значение другой константы:
enum DayTime
Источник: metanit.com
C#. Урок 7. Типы перечислений enum
Для представления набора связанных констант с символьными именами язык C# предоставляет инструмент: типы перечислений – enum‘ы. О том как создавать и работать с объектами такого типа будет рассказано в данном уроке.
- Типы перечислений enum
- Работа с переменными типа перечисления
- Тип System.Enum
- Определение типа элемента перечисления
- Конвертация числа в константу перечисления
- Проверка наличия целочисленного (или строкового) значения в заданном перечислении
- Форматированное строковое представление значения перечисления
- Преобразование строки или числа в значение перечисления
- Получение имен элементов перечисления и их численных значений в виде массивов
Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.
Типы перечислений enum
Тип перечисление ( enum ) представляет собой набор символьных имен, связанных с уникальными целочисленными значениями. Для объявления этого типа используется оператор enum. После оператора enum указывается имя создаваемого типа. Через двоеточие можно указать тип констант перечисления (должен быть целочисленным). Если не указывать тип явно, то будет использован int.
После этого приводится список символьных констант через запятую. Пример типа перечисления:
enum TypeOS
Каждому элементу перечисления присваивается целочисленное значение, в примере выше, эти значения начинаются с нуля и, далее, увеличиваются на единицу. Можно явно задать значения элементам перечисления. Для этого C# предоставляет два варианта: первый – это задание численного значения первому элементу, при этом все остальные, по очереди, принимают значения на единицу больше:
enum TypeOS
Второй вариант предполагает явное задание численных значений каждому элементу перечисления индивидуально:
enum TypeOS
Работа с переменными типа перечисления
Создадим следующий тип перечисление для экспериментов:
enum WeekDay
С элементами типа перечисления можно производить различные операции – это приведение значения к целочисленному типу, операции сравнения (==, !=, и т.п.), арифметические операции: сложение и вычитание, логические операции ( int dayNum; wd = WeekDay.Friday; Console.WriteLine($»Пример дня недели: «); dayNum = (int)wd; Console.WriteLine($» идет в перечислении под номером «); wd -= 3; dayNum = (int)wd; Console.WriteLine($» идет в перечислении под номером «);
Как было сказано в Уроке 6, enum может быть результатом выражения в операторе switch . Создадим метод, который в зависимости от дня недели будет выдавать занятие по расписанию:
static void WorkAtDay(WeekDay wd) < switch (wd) < case WeekDay.Monday: Console.WriteLine($»- Физкультура»); break; case WeekDay.Friday: Console.WriteLine($» — Литература»); break; case WeekDay.Wednesday: Console.WriteLine($» — Математика»); break; default: Console.WriteLine($» — День отдыха»); break; > >
Продемонстрируем работу этого метода:
WorkAtDay(WeekDay.Monday); WorkAtDay(WeekDay.Friday); WorkAtDay((WeekDay)3); WorkAtDay(WeekDay.Sunday);
Тип System.Enum
Базовым классом для всех перечислений является System.Enum . Он включает в себя различные методы, которые позволяют получить сведения о типе перечисления и его значениях. Далее будут более подробно рассмотрены возможности, предоставляемые этим классом. Создадим enum для представления времен года, с ним мы будем работать в разделах, приведенных ниже:
enum Season
Определение типа элемента перечисления
Для получения значения типа элемента перечисления используйте метод GetType непосредственно у самого элементы. Метод GetUnderlyingType у типа System.Enum возвращает базовый тип перечисления:
Console.WriteLine($»Тип элемента Season.Spring: «); Console.WriteLine($»Базовый тип элемента Season.Spring: «);
Конвертация числа в константу перечисления
Метод ToObject конвертирует целочисленное значение в экземпляр перечисления указанного типа:
Type enumType = Season.Spring.GetType(); int n1 = 3; int n2 = 0; Console.WriteLine($»Преобразование числа в перечисление Season: «); Console.WriteLine($»Преобразование числа в перечисление Season: «);
Необходимо учитывать, что если ToObject применить к числу, которое не совпадает со значениями у элементов перечисления, то метод будет выполнен, но ничего не преобразует:
int n3 = 5; Console.WriteLine($»Преобразование числа в перечисление Season «);
Для исключения таких случаев рекомендуется перед преобразованием использовать метод IsDefined .
Проверка наличия целочисленного (или строкового) значения в заданном перечислении
Для проверки наличия заданного целочисленного значения или имени в виде строки среди элементов перечисления используется метод IsDefined(Type, Object) , который в качестве аргументов принимает тип и значение для проверки:
int n4 = 5; Console.WriteLine($»Существует ли элемент под номером в перечислении: «);
Форматированное строковое представление значения перечисления
Метод Format предоставляет возможность форматированного конвертирования перечисления в строку:
var season = Season.Winter; Console.WriteLine($»Численное значение времени года : .»); Console.WriteLine($»Значение в формате hex времени года : .»);
Преобразование строки или числа в значение перечисления
Метод Parse преобразует строку (или число) в значение перечисления указанного типа. Значение и тип передаются в качестве аргументов методу, также можно дополнительно использоваться параметр ignoreCase для игнорирования регистра:
string[] arr = < «5», «0», «3», «Autumn», «Summer, Winter» >; foreach (var strVal in arr) < var seasonVal = (Season)Enum.Parse(typeof(Season), strVal, true); Console.WriteLine($»Преобразовали «» в «); >
Получение имен элементов перечисления и их численных значений в виде массивов
Для получения имен элементов перечисления в виде массива строк, используется метод GetNames :
Console.WriteLine(«Элементы перечисления Season:»); foreach (string s in Enum.GetNames(typeof(Season)))
Массив численных значений можно получить с помощью метода GetValues :
Console.WriteLine(«Численные значения элементов перечисления Season:»); foreach (int s in Enum.GetValues(typeof(Season)))
Битовые флаги
Перечисление можно представить как хранилище битовых флагов, это позволяет применять к элементам перечисления побитовые операции И ( AND ), ИЛИ (OR) и исключающее ИЛИ (XOR) .
Для использования перечислений как наборов битовых флагов необходимо:
- При объявлении перечисления использовать атрибут flags.
- Константы должны быть определены как степень двойки. Для констант лучше использовать только положительные значения.
Ниже представлен пример, демонстрирующий работу с битовыми флагами:
[Flags] enum Mounts < January = 2, February = 4, March = 8, April = 16, May = 32, June = 64, July = 128, August = 256, September = 512, October = 1024, November = 2048, December = 4096, Winter = November | December | January >// Этот код нужно вставить в Main Mounts summerMount = Mounts.June | Mounts.July | Mounts.August; Console.WriteLine($»Летние месяцы: «); Mounts secondSemester = summerMount | Mounts.September | Mounts.October | Mounts.November; Console.WriteLine($»Осенние месяцы: < summerMount ^ secondSemester>»);
Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.
Раздел: .NET / C# Уроки по C# Метки: .NET, C#, Уроки по C#
C#. Урок 7. Типы перечислений enum : 1 комментарий
- Максим 08.06.2021 В последнем примере наименование перечисления с именем Mounts не очевидно. Наверное должно быть Months
Источник: devpractice.ru
Как правильно использовать enum в C#
В C# есть много интересных возможностей, помогающих разработчикам писать код на языке, который похож на человеческий. Одна из таких полезных штук – списки перечислений.
Давайте посмотрим, что такое enum в C# и как им пользоваться.
Что такое enum в C#
Enum – пользовательский тип данных, который представляет собой набор именованных целочисленных констант. По сути, это список однотипных значений: дней недели, кодов ответа сервера, арифметических действий.
В C# есть встроенный список цветов. Это отличный пример enum. Пользователю не нужно каждый раз вводить код цвета. Он просто выбирает значение из подготовленного заранее списка.
using System; class HelloWorld < static void Main() < //По умолчанию вывод в консоли белого цвета Console.WriteLine(«Hello, World!»); //Изменили цвет на зеленый, выбрав его из списка Console.ForegroundColor = ConsoleColor.Green; //Теперь вывод в консоли зеленого цвета Console.WriteLine(«Hello, World!»); >>
Комьюнити теперь в Телеграм
Подпишитесь и будьте в курсе последних IT-новостей
Как создать enum в C#
Теперь давайте разберемся, как создать enum в C#. Общая структура списка выглядит так:
enum Название_типа : целочисленный_тип
- Сначала – ключевое слово enum. Оно указывает, что это перечисление.
- Затем мы задаем название типа. Им может быть любая строка, которую допустимо использовать в именах переменных.
- После двоеточия указывается тип данных констант, которые будут входить в состав перечисления. По умолчанию это int.
- В фигурных скобках перечисляются сами константы.
В качестве примера создадим перечисление простейших математических операций:
enum Math
У нас есть понятный список операций, который можно использовать для создания методов и при необходимости расширять.
Как использовать enum
Возьмем наше перечисление математических операций и посмотрим, как правильно использовать enum.
В качестве примера создадим метод DoMath, используя конструкцию switch.
static double DoMath(double a, double b, Math operation) < return operation switch < Math.Add =>a + b, Math.Divide => a / b, Math.Multiply => a * b, Math.Subtract => a — b, _ => throw new Exception(«Неизвестное действие») >; >
В методе используется перечисление Math, которое позволяет пользователю выбрать нужное арифметическое действие. Например, нужно выполнить умножение:
static void Main(string[] args)
В консоли будет выведено число 44.
Как enum улучшает читаемость кода
Главный плюс enum – код становится более читаемым. Не нужно каждый раз проверять реализацию класса, чтобы понять, за что отвечает аргумент и что он вообще делает. Enum дает возможность понятно описывать разные значения.
С enum также проще масштабировать код. Например, у нас есть список с простыми арифметическими действиями. Мы можем легко его расширить, добавив новую константу. А затем использовать ее в методе DoMath или в другом месте программы.
Заключение
Использование enum – хорошая практика. Перечисления в C# помогают разработчикам писать более читаемый и легко масштабируемый код. Их также часто используют для ограничения количества вариантов.
Источник: timeweb.com