Перечислимый тип

В компьютерном программировании ( перечислимый тип также называемый перечислением , enum или фактором в языке программирования R и категориальной переменной в статистике) — это тип данных, состоящий из набора именованных значений называемых элементами , членами , перечислениями или перечислителями , тип. Имена перечислителей обычно представляют собой идентификаторы ведут себя как константы , которые в языке . Перечисляемый тип можно рассматривать как вырожденное объединение тегов единичного типа . Переменной , объявленной как имеющая перечисляемый тип, можно присвоить в качестве значения любой из перечислителей. Другими словами, перечислимый тип имеет значения, которые отличаются друг от друга, и их можно сравнивать и присваивать, но они не указаны программистом как имеющие какое-либо конкретное представление в памяти компьютера; компиляторы и интерпретаторы могут представлять их произвольно.

Например, четыре масти в колоде игральных карт могут быть четырьмя перечислителями с именами Club , Diamond , Heart и Spade , принадлежащими к перечисляемому типу с именем масти . Если переменная V объявлена ​​с типом данныхsuit , ей можно присвоить любое из этих четырех значений.

Хотя перечислители обычно различны, в некоторых языках допускается указание одного и того же перечислителя дважды в объявлении типа. Имена счетчиков не обязательно должны быть семантически полными или совместимыми в каком-либо смысле. Например, перечислимый тип с именем color может быть определен как состоящий из перечислителей Red , Green , Zebra , Missing и Bacon . В некоторых языках объявление перечислимого типа также намеренно определяет порядок его членов ( высокий , средний и низкий приоритеты); в других перечислители неупорядочены ( поддерживаются английский , французский , немецкий и испанский языки); в других случаях неявное упорядочение возникает из-за того, что компилятор конкретно представляет перечислители как целые числа.

Некоторые типы перечислителей могут быть встроены в язык. Например, тип Boolean часто представляет собой заранее определенное перечисление значений False и True . Тип единицы измерения, состоящий из одного значения, также может быть определен для представления null . Многие языки позволяют пользователям определять новые перечислимые типы.

Значения и переменные перечислимого типа обычно реализуются с использованием некоторого целочисленного типа в качестве базового представления. Некоторые языки, особенно языки системного программирования , позволяют пользователю указывать битовую комбинацию, которая будет использоваться для каждого перечислителя, что может быть полезно для эффективного представления наборов перечислителей в виде битовых строк фиксированной длины. В теории типов перечислимые типы часто рассматриваются как тегированные объединения единичных типов . Поскольку такие типы имеют вид $1+1+\cdots +1$, они также могут быть записаны как натуральные числа.

Обоснование

Некоторые ранние языки программирования изначально не имели перечисляемых типов. Если программист хотел, чтобы переменная, например myColor , имела значение красного цвета, переменная red должна быть объявлена ​​и ей присвоено произвольное значение, обычно целочисленная константа. Переменная red будет затем присвоена myColor . Другие методы присваивали произвольные значения строкам, содержащим имена перечислителей.

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

С другой стороны, перечислимые типы делают код более самодокументируемым. В зависимости от языка компилятор может автоматически присваивать перечислителям значения по умолчанию, тем самым скрывая от программиста ненужные детали. Эти значения могут быть даже не видны программисту (см. скрытие информации ). Перечислимые типы также могут помешать программисту писать нелогичный код, например выполнять математические операции над значениями перечислителей. Если бы значение переменной, которой был назначен перечислитель, должно было быть напечатано, некоторые языки программирования также могли бы печатать имя перечислителя, а не его базовое числовое значение. Еще одним преимуществом является то, что перечислимые типы позволяют компиляторам обеспечивать семантическую корректность. Например: myColor = TRIANGLE может быть запрещено, хотя myColor = RED принимается, даже если TRIANGLE и RED оба внутренне представлены как 1 .

Концептуально перечислимый тип аналогичен списку номиналов (числовых кодов), поскольку каждому возможному значению типа присваивается отличительное натуральное число. Таким образом, данный перечислимый тип является конкретной реализацией этого понятия. Когда порядок имеет смысл и/или используется для сравнения, перечисляемый тип становится порядковым типом.

Конвенции

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

Синтаксис в нескольких языках программирования

Паскаль и синтаксически подобные языки.

Паскаль

В Pascal перечислимый тип может быть неявно объявлен путем перечисления значений в списке в круглых скобках:

  var
    suit: (clubs, diamonds, hearts, spades);

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

  type
    cardsuit = (clubs, diamonds, hearts, spades);
    card = record
             suit: cardsuit;
             value: 1 .. 13;
           end;
  var
    hand: array [ 1 .. 13 ] of card;
    trump: cardsuit;

Порядок, в котором задаются значения перечисления, имеет значение. Перечислимый тип является порядковым типом, а pred и succ функции дадут предыдущее или следующее значение перечисления, и ord может преобразовывать значения перечисления в их целочисленное представление. Однако стандартный Паскаль не предлагает преобразования арифметических типов в перечисления. Extended Pascal предлагает эту функциональность через расширенный succ функция. Некоторые другие диалекты Паскаля допускают это посредством приведения типов. Некоторые современные потомки Паскаля, такие как Modula-3 , предоставляют специальный синтаксис преобразования с использованием метода, называемого VAL; Модуль-3 также лечит BOOLEAN и CHAR как специальные предопределенные перечислимые типы и способы использования. ORD и VAL для стандартного декодирования и кодирования ASCII.

Языки стиля Паскаль также позволяют использовать перечисление в качестве индекса массива:

  var
    suitcount: array [cardsuit] of integer;

Есть

В Ada использование «=" было заменено на «is», оставив определение очень похожим:

type Cardsuit is (clubs, diamonds, hearts, spades);

В дополнение к Pred, Succ, Val и Pos Ada также поддерживает простые преобразования строк через Image и Value.

Подобно языкам C-стиля, Ada позволяет указать внутреннее представление перечисления:

for Cardsuit use
  (clubs => 1, diamonds => 2, hearts => 4, spades => 8);

В отличие от языков C-стиля, Ada также позволяет указывать количество бит перечисления:

for Cardsuit'Size use 4;  -- 4 bits

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

   Shuffle : constant array(Cardsuit) of Cardsuit :=
     (Clubs => Cardsuit'Succ(Clubs), -- see attributes of enumerations 'First, 'Last, 'Succ, 'Pred
      Diamonds => Hearts, --an explicit value
      Hearts => Cardsuit'Last, --first enumeration value of type Cardsuit e.g., clubs
      Spades => Cardsuit'First --last enumeration value of type Cardsuit e.g., spades
      );

Как Модуль-3 Есть вкусняшки Boolean и Character как специальное предопределенное (в пакете " Standard") перечислимые типы. В отличие от Модулы-3 можно также определять собственные типы символов:

type Cards is ('7', '8', '9', 'J', 'Q', 'K', 'A');

C и синтаксически подобные языки

С

Исходный диалект K&R языка программирования C не имел перечислимых типов. В C перечисления создаются с помощью явных определений (теперь enum ключевое слово само по себе не вызывает выделения памяти), которые используют enum ключевое слово и напоминают определения структур и объединений :

enum cardsuit {
    Clubs,
    Diamonds,
    Hearts,
    Spades
};

struct card {
    enum cardsuit suit;
    short int value;
} hand[13];

enum cardsuit trump;

C предоставляет целочисленное представление значений перечисления непосредственно программисту. Целые числа и перечислимые значения можно свободно смешивать, и все арифметические операции над перечисляемыми значениями разрешены. Переменная перечисления может даже содержать целое число, которое не представляет ни одного из значений перечисления. Фактически, согласно определению языка, приведенный выше код будет определять Clubs, Diamonds, Hearts, и Spades как константы типа int, который будет преобразован (тихо) только в enum cardsuit если они хранятся в переменной этого типа.

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

enum cardsuit {
    Clubs    = 1,
    Diamonds = 2,
    Hearts   = 4,
    Spades   = 8
};

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

Начиная с C23 , базовый тип перечисления может быть указан программистом:

enum cardsuit : char {
    Clubs    = 1,
    Diamonds = 2,
    Hearts   = 4,
    Spades   = 8
};

С#

Перечислимые типы в языке программирования C# сохраняют большую часть семантики «малых целых чисел» перечислений C. Некоторые арифметические операции не определены для перечислений, но значение перечисления может быть явно преобразовано в целое число и обратно, а переменная перечисления может иметь значения, которые не были объявлены определением перечисления. Например, учитывая

enum Cardsuit
{
    Clubs,
    Diamonds,
    Spades,
    Hearts
}

выражения CardSuit.Diamonds + 1 и CardSuit.Hearts - CardSuit.Clubs разрешены напрямую (поскольку может иметь смысл просмотреть последовательность значений или спросить, сколько шагов между двумя значениями), но CardSuit.Hearts * CardSuit.Spades считается не имеющим смысла и допускается только в том случае, если значения сначала преобразуются в целые числа.

C# также предоставляет подобную C возможность определять конкретные целочисленные значения для перечислений. Благодаря этому можно выполнять двоичные операции над перечислениями, рассматривая таким образом значения перечисления как наборы флагов. Эти флаги можно проверить с помощью двоичных операций или с помощью встроенного метода HasFlag типа Enum.

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

С++

В C++ есть типы перечислений, которые напрямую унаследованы от C и работают в основном аналогично этим, за исключением того, что перечисление является реальным типом в C++, что обеспечивает дополнительную проверку во время компиляции. Кроме того (как и в случае со структурами), C++ enum ключевое слово сочетается с typedef , чтобы вместо присвоения имени типу enum name, просто назовите его name. Это можно смоделировать в C, используя typedef: typedef enum {Value1, Value2} name;

В C++11 также предусмотрен второй вид перечисления, называемый перечислением с ограниченной областью действия . Они типобезопасны: перечислители не преобразуются неявно в целочисленный тип. Помимо прочего, это позволяет определить потоковую передачу ввода-вывода для типа перечисления. Другая особенность перечислений с ограниченной областью заключается в том, что перечислители не утекают, поэтому для их использования требуется префикс с именем перечисления (например, Color::Red для первого перечислителя в приведенном ниже примере), если только using enum Объявление (представленное в C++20 ) использовалось для перевода перечислителей в текущую область. Ограниченное перечисление задается фразой enum class (или enum struct). Например:

enum class Color {Red, Green, Blue};

Базовый тип перечисления — это определяемый реализацией целочисленный тип, достаточно большой для хранения всех перечисляемых значений; это не обязательно должен быть наименьший возможный тип. Базовый тип может быть указан напрямую, что позволяет «упреждающие объявления» перечислений:

enum class Color : long {Red, Green, Blue};  // must fit in size and memory layout the type 'long'
enum class Shapes : char;  // forward declaration. If later there are values defined that don't fit in 'char' it is an error.

Идти

Go использует iota ключевое слово для создания перечислимых констант.

type ByteSize float64

const (
    _           = iota // ignore first value by assigning to blank identifier
    KB ByteSize = 1 << (10 * iota)
    MB
    GB
)

Смешанный

Этот раздел представляет собой отрывок из Haxe § Перечислимые типы . [ редактировать ]

Перечислимые типы — важная особенность языка; они могут иметь параметры типа и быть рекурсивными. Они обеспечивают базовую поддержку алгебраических типов данных , позволяя включать типы продуктов аналогично Haskell и ML . А switch Выражение может применять сопоставление шаблонов со значением перечисления, что позволяет элегантно решать сложные проблемы программирования:

enum Color {
	red;
	green;
	blue;
	rgb(r:Int, g:Int, b:Int);
}

class Colors {
	static function toInt(c:Color):Int {
		return switch (c) {
			case red: 0xFF0000;
			case green: 0x00FF00;
			case blue: 0x0000FF;
			case rgb(r, g, b): (r << 16) | (g << 8) | b;
		}
	}

	static function validCalls() {
		var redint = toInt(Color.red);
		var rgbint = toInt(Color.rgb(100, 100, 100));
	}
}

Примерами параметрических типов перечислений являются типы стандартной библиотеки Haxe. и Либо:

enum Option<T> {
    Some(v:T);
    None;
}

enum Either<L, R> {
    Left(v:L);
    Right(v:R);
}

Haxe также поддерживает обобщенные алгебраические типы данных (GADT).

Ява

A UML class diagram featuring a enum.

В J2SE версии 5.0 языка программирования Java добавлены перечислимые типы, синтаксис объявления которых следующий: аналогично C :

enum Cardsuit { CLUBS, DIAMONDS, SPADES, HEARTS };
...
Cardsuit trump;

Однако система типов Java рассматривает перечисления как тип, отдельный от целых чисел, и смешивание значений перечислений и целых чисел не допускается. Фактически, перечислимый тип в Java на самом деле представляет собой специальный класс , созданный компилятором , а не арифметический тип, и значения перечисления ведут себя как глобальные предварительно сгенерированные экземпляры этого класса. Перечисляемые типы могут иметь методы экземпляра и конструктор (аргументы которого можно указывать отдельно для каждого значения перечисления). Все типы перечислений неявно расширяют Enum абстрактный класс. Тип перечисления не может быть создан напрямую.

Внутри каждое значение перечисления содержит целое число, соответствующее порядку, в котором они объявлены в исходном коде, начиная с 0. Программист не может напрямую установить собственное целое число для значения перечисления, но можно определить перегруженные конструкторы , которые затем могут назначать произвольные значения для самоопределенных членов класса перечисления. Определение геттеров позволяет получить доступ к этим самоопределенным членам. Внутреннее целое число можно получить из значения перечисления, используя метод ordinal() метод, а список перечисляемых значений перечислимого типа можно получить по порядку с помощью метода values() метод. Программистам обычно не рекомендуется преобразовывать перечисления в целые числа и наоборот. Перечислимые типы Comparable, используя внутреннее целое число; в результате их можно отсортировать.

Стандартная библиотека Java предоставляет служебные классы для использования с перечислениями. EnumSet класс реализует Set значений перечисления; он реализован как битовый массив , что делает его очень компактным и таким же эффективным, как явная манипуляция битами, но более безопасным. EnumMap класс реализует Map значений перечисления для объекта. Он реализован как массив, в котором целочисленное значение значения перечисления служит индексом.

Перл

Динамически типизированные языки синтаксической традиции C (например, Perl или JavaScript ) обычно не предоставляют перечисления. Но в программировании на Perl тот же результат можно получить с помощью сокращенного строк списка и хешей (возможно, срезов ):

my @enum = qw(Clubs Diamonds Hearts Spades);
my( %set1, %set2 );
@set1{@enum} = ();          # all cleared
@set2{@enum} = (1) x @enum; # all set to 1
$set1{Clubs} ...            # false
$set2{Diamonds} ...         # true

Раку

Raku (ранее известный как Perl 6) поддерживает перечисления. В Raku существует несколько способов объявления перечислений, каждый из которых создает внутреннюю карту.

enum Cat <sphynx siamese bengal shorthair other>; # Using "quote-words"

enum Cat ('sphynx', 'siamese', 'bengal', 'shorthair', 'other'); # Using a list

enum Cat (sphynx => 0, siamese => 1, bengal => 2, shorthair => 3, other => 4); # Using Pair constructors

enum Cat (:sphynx(0), :siamese(1), :bengal(2), shorthair(3), :other(4)); # Another way of using Pairs, you can also use `:0sphynx`

PHP

Перечисления были добавлены в PHP версии 8.1.

enum CardSuit
{
    case Hearts;
    case Diamonds;
    case Clubs;
    case Spades;
}

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

enum CardSuit: string
{
    case Hearts = 'H';
    case Diamonds = 'D';
    case Clubs = 'C';
    case Spades = 'S';
}

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

Ржавчина

Хотя Rust использует enum ключевое слово, такое как C, он использует его для описания тегированных объединений , перечисления которых можно считать вырожденной формой. Таким образом, перечисления в Rust гораздо более гибкие и могут содержать варианты структур и кортежей.

enum Message {
    Quit,
    Move { x: i32, y: i32 }, // struct
    Write(String), // single-element tuple
    ChangeColor(i32, i32, i32), // three-element tuple
}

Быстрый

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

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

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

enum CardSuit {
    case clubs
    case diamonds
    case hearts
    case spades
}

В отличие от C и Objective-C , случаям перечисления Swift не присваивается целочисленное значение по умолчанию при их создании. В приведенном выше примере CardSuit трефы, бубны, червы и пики не являются неявно равными 0, 1, 2 и 3. Вместо этого различные случаи перечисления сами по себе являются полноценными значениями с явно определенным типом CardSuit. .

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

enum CardSuit {
    case clubs, diamonds, hearts, spades
}

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

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

enum CardSuit {
    case clubs = 1, diamonds, hearts, spades
}

Машинопись

TypeScript добавляет в JavaScript тип данных enum.

enum Cardsuit {Clubs, Diamonds, Hearts, Spades};
var c: Cardsuit = Cardsuit.Diamonds;

По умолчанию члены перечисления нумеруются, начиная с 0; это можно переопределить, установив значение первого:

enum Cardsuit {Clubs = 1, Diamonds, Hearts, Spades};
var c: Cardsuit = Cardsuit.Diamonds;

Все значения могут быть установлены:

enum Cardsuit {Clubs = 1, Diamonds = 2, Hearts = 4, Spades = 8};
var c: Cardsuit = Cardsuit.Diamonds;

TypeScript поддерживает сопоставление числового значения с его именем. Например, это находит имя значения 2:

enum Cardsuit {Clubs = 1, Diamonds, Hearts, Spades};
var suitName: string = Cardsuit[2];

alert(suitName);

Питон

Ан enum Модуль был добавлен в стандартную библиотеку Python в версии 3.4.

from enum import Enum
class Cards(Enum):
    CLUBS = 1
    DIAMONDS = 2
    HEARTS = 3
    SPADES = 4

Также имеется функциональный API для создания перечислений с автоматически генерируемыми индексами (начиная с единицы):

Cards = Enum("Cards", "CLUBS DIAMONDS HEARTS SPADES")

Перечисления Python не обеспечивают семантическую корректность (бессмысленное сравнение с несовместимым перечислением всегда возвращает False, а не вызывает TypeError ):

>>> Color = Enum("Color", "RED GREEN BLUE")
>>> Shape = Enum("Shape", ["CIRCLE", "TRIANGLE", "SQUARE", "HEXAGON"])
>>> def has_vertices(shape):
... 	return shape != Shape.CIRCLE
...
>>> has_vertices(Color.GREEN)
True

Фортран

В Фортране есть только нумерованные типы для совместимости с C; следовательно, семантика аналогична C, и, как и в C, значения перечисления являются просто целыми числами, и дополнительная проверка типов не выполняется. Приведенный выше пример C можно записать на Фортране как

enum, bind( C )
  enumerator :: CLUBS = 1, DIAMONDS = 2, HEARTS = 4, SPADES = 8
end enum

Visual Basic/VBA

Перечисляемым типам данных в Visual Basic (до версии 6) и VBA автоматически присваивается " Long" тип данных, а также сами становятся типом данных:

'Zero-based
Enum CardSuit
    Clubs
    Diamonds
    Hearts
    Spades
End Enum

Sub EnumExample()
    Dim suit As CardSuit
    suit = Diamonds
    MsgBox suit
End Sub

Пример кода в VB.NET

Enum CardSuit
    Clubs
    Diamonds
    Hearts
    Spades
End Enum

Sub EnumExample()
    Dim suit As CardSuit
    suit = CardSuit.Diamonds
    MessageBox.show(suit)
End Sub

Лисп

Common Lisp использует спецификатор типа члена, например:

(deftype cardsuit ()
  '(member club diamond heart spade))

в котором говорится, что объект относится к типу карточной масти, если он #'eql трефу, бубну, черву или пику. Однако спецификатор типа члена недопустим в качестве спецификатора параметров Common Lisp Object System (CLOS). Вместо, (eql atom), что эквивалентно (member atom) может использоваться (то есть только один член набора может быть указан с помощью спецификатора типа eql, однако его можно использовать в качестве специалиста параметра CLOS.) Другими словами, чтобы определить методы для покрытия перечислимого типа, необходимо использовать метод должен быть определен для каждого конкретного элемента этого типа.

Кроме того,

(deftype finite-element-set-type (&rest elements)
   `(member ,@elements))

может использоваться для определения произвольных перечислимых типов во время выполнения. Например

(finite-element-set-type club diamond heart spade)

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

(member club diamond heart spade)

но может быть менее запутанно с функцией #'member по стилистическим соображениям.

Дарт

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

enum CardSuite {
  Clubs,
  Diamonds,
  Hearts,
  Spades
}

void main() {
  CardSuite card = CardSuite.Clubs;

  // Dart uses the "switch" operator to match the value of an enum with the desired output.
  switch (card) {
    case CardSuite.Clubs: {
      print("Clubs");
    }
    break;

    case CardSuite.Diamonds: {
      print("Diamonds");
    }
    break;

    case CardSuite.Hearts: {
      print("Hearts");
    }
    break;

    case CardSuite.Spades: {
      print("Spades");
    }
    break;

    default: {
      print("Unknown");
    }
    break;
  }
}

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

Алгебраический тип данных в функциональном программировании

В функционального программирования языках линии ML (например, Standard ML (SML), OCaml и Haskell ) алгебраический тип данных только с нулевыми конструкторами для реализации перечислимого типа может использоваться . Например (в синтаксисе подписей SML):

datatype cardsuit = Clubs | Diamonds | Hearts | Spades
type card = { suit: cardsuit; value: int }
val hand : card list
val trump : cardsuit

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

Базы данных

Некоторые базы данных напрямую поддерживают перечислимые типы. MySQL предоставляет перечислимый тип ENUM с допустимыми значениями, указанными в виде строк при создании таблицы. Значения сохраняются как числовые индексы, при этом пустая строка сохраняется как 0, первое строковое значение сохраняется как 1, второе строковое значение сохраняется как 2 и т. д. Значения можно сохранять и извлекать как числовые индексы или строковые значения.

Пример:

CREATE TABLE shirts (
    name VARCHAR(40),
    size ENUM('x-small', 'small', 'medium', 'large', 'x-large')
);

XML-схема

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

<xs:element name="cardsuit">
  <xs:simpleType>
    <xs:restriction base="xs:string">
      <xs:enumeration value="Clubs"/>
      <xs:enumeration value="Diamonds"/>
      <xs:enumeration value="Hearts"/>
      <xs:enumeration value="Spades"/>
    </xs:restriction>
  </xs:simpleType>
</xs:element>

См. также

• Контрастный набор

Внешние ссылки

• Перечисляемые типы в C/C++
• Перечисляемые типы в C#
• Перечисляемые типы в Java
• Перечисляемые типы в MySQL
• Перечислимые типы в Obix
• Перечисляемые типы в PHP
• Перечисляемые типы в Swift
• Перечисляемые типы в XML
• Перечисляемые типы в Visual Basic