Type énuméré - Enumerated type

Dans la programmation informatique , un type énuméré (également appelé énumération , ENUM ou facteur dans le langage de programmation R , et une variable catégorique dans les statistiques) est un type de données constitué d'un ensemble de nommées valeurs appelées éléments , membres , de type énuméré , ou recenseurs de le type. Les noms des énumérateurs sont généralement des identifiants qui se comportent comme des constantes dans la langue. Un type énuméré peut être vu comme une union étiquetée dégénérée de type unité . Une variable qui a été déclarée comme ayant un type énuméré peut se voir affecter n'importe quel énumérateur en tant que valeur. En d'autres termes, un type énuméré a des valeurs qui sont différentes les unes des autres, et qui peuvent être comparées et attribuées, mais ne sont pas spécifiées par le programmeur comme ayant une représentation concrète particulière dans la mémoire de l'ordinateur ; les compilateurs et les interprètes peuvent les représenter arbitrairement.

Par exemple, les quatre couleurs dans un jeu de cartes à jouer peuvent être quatre énumérateurs nommés Club , Diamant , Cœur et Pique , appartenant à un type d'énumération nommé couleur . Si une variable V est déclarée ayant suit comme type de données, on peut lui affecter n'importe laquelle de ces quatre valeurs.

Bien que les énumérateurs soient généralement distincts, certains langages peuvent permettre au même énumérateur d'être répertorié deux fois dans la déclaration du type. Les noms des agents recenseurs n'ont pas besoin d'être sémantiquement complets ou compatibles en aucun sens. Par exemple, un type énuméré appelé couleur peut être défini pour se composer des énumérateurs Red , Green , Zebra , Missing et Bacon . Dans certains langages, la déclaration d'un type énuméré définit également intentionnellement un ordre de ses membres ; dans d'autres, les recenseurs ne sont pas ordonnés ; dans d'autres encore, un ordre implicite provient du compilateur représentant concrètement les énumérateurs sous forme d'entiers.

Certains types d'énumérateur peuvent être intégrés au langage. Le type booléen , par exemple, est souvent une énumération prédéfinie des valeurs False et True . De nombreux langages permettent aux utilisateurs de définir de nouveaux types énumérés.

Les valeurs et les variables d'un type énuméré sont généralement implémentées sous forme de chaînes de bits de longueur fixe , souvent dans un format et une taille compatibles avec un type d' entier . Certains langages, en particulier les langages de programmation système , permettent à l'utilisateur de spécifier la combinaison de bits à utiliser pour chaque énumérateur. Dans la théorie des types, les types énumérés sont souvent considérés comme des unions étiquetées de types unitaires . Étant donné que ces types sont de la forme , ils peuvent également être écrits sous forme de nombres naturels. ${\displaystyle 1+1+\cdots +1}$

Raisonnement

Certains premiers langages de programmation n'avaient pas à l'origine de types énumérés. Si un programmeur voulait qu'une variable, par exemple myColor , ait une valeur de rouge, la variable rouge serait déclarée et assignée une valeur arbitraire, généralement une constante entière. La variable rouge serait alors affectée à myColor . D'autres techniques attribuaient des valeurs arbitraires aux chaînes contenant les noms des énumérateurs.

Ces valeurs arbitraires étaient parfois appelées nombres magiques car il n'y avait souvent aucune explication sur la façon dont les nombres étaient obtenus ou si leurs valeurs réelles étaient significatives. Ces nombres magiques pourraient rendre le code source plus difficile à comprendre et à maintenir pour les autres.

Les types énumérés, en revanche, rendent le code plus auto-documenté. Selon le langage, le compilateur pourrait attribuer automatiquement des valeurs par défaut aux énumérateurs, cachant ainsi des détails inutiles au programmeur. Ces valeurs peuvent même ne pas être visibles pour le programmeur (voir masquage d'informations ). Les types énumérés peuvent également empêcher un programmeur d'écrire du code illogique tel que l'exécution d'opérations mathématiques sur les valeurs des énumérateurs. Si la valeur d'une variable affectée à un énumérateur devait être imprimée, certains langages de programmation pourraient également imprimer le nom de l'énumérateur plutôt que sa valeur numérique sous-jacente. Un autre avantage est que les types énumérés peuvent permettre aux compilateurs d'appliquer l'exactitude sémantique. Par exemple : myColor = TRIANGLE peut être interdit, tandis que myColor = RED est accepté, même si TRIANGLE et ROUGE sont tous deux représentés en interne par 1 .

Conceptuellement, un type énuméré est similaire à une liste de nominaux (codes numériques), puisque chaque valeur possible du type se voit attribuer un nombre naturel distinctif. Un type énuméré donné est donc une implémentation concrète de cette notion. Lorsque l'ordre est significatif et/ou utilisé à des fins de comparaison, un type énuméré devient un type ordinal .

Conventions

Les langages de programmation ont tendance à avoir leurs propres styles de programmation et conventions de dénomination , souvent multiples . La variable affectée à une énumération est généralement un nom au singulier et suit fréquemment une convention PascalCase ou majuscule , tandis que les minuscules et autres sont moins fréquemment vues.

Syntaxe dans plusieurs langages de programmation

Pascal et langages syntaxiquement similaires

Pascal

En Pascal , un type énuméré peut être déclaré implicitement en listant les valeurs dans une liste entre parenthèses :

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

La déclaration apparaîtra souvent dans une déclaration de synonyme de type, de sorte qu'elle peut être utilisée pour plusieurs variables :

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

L'ordre dans lequel les valeurs d'énumération sont données est important. Un type énuméré est un type ordinal, et les fonctions predet succdonneront la valeur précédente ou suivante de l'énumération et ordpeuvent convertir les valeurs d'énumération en leur représentation entière. Le Pascal standard n'offre cependant pas de conversion des types arithmétiques en énumérations. Pascal étendu offre cette fonctionnalité via une succfonction étendue . Certains autres dialectes Pascal le permettent via des transtypages. Certains descendants modernes de Pascal, tels que Modula-3 , fournissent une syntaxe de conversion spéciale à l'aide d'une méthode appelée VAL; Modula-3 traite également BOOLEANet CHARcomme des types et des utilisations énumérés prédéfinis spéciaux ORDet VALpour le décodage et l'encodage ASCII standard .

Les langages de style Pascal permettent également d'utiliser l'énumération comme index de tableau :

  var
    suitcount: array [cardsuit] of integer;

Ada

Dans Ada , l'utilisation de "=" a été remplacée par "is" laissant la définition assez similaire :

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

En plus Pred, Succ, Valet PosAda prend également en charge les conversions de chaînes simples via Imageet Value.

Similaire aux langages de style C, Ada permet de spécifier la représentation interne de l'énumération :

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

Contrairement aux langages de style C, Ada permet également de spécifier le nombre de bits de l'énumération :

for Cardsuit'Size use 4;  -- 4 bits

De plus, on peut utiliser des énumérations comme index pour les tableaux, comme en Pascal, mais il existe des attributs définis pour les énumérations

   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
      );

Comme Modula-3 Ada traite Booleanet Charactercomme des Standardtypes énumérés prédéfinis spéciaux (dans le package " "). Contrairement à Modula-3, on peut également définir ses propres types de caractères :

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

C et langages syntaxiquement similaires

C

Le dialecte K&R d'origine du langage de programmation C n'avait pas de types énumérés. En C, les énumérations sont créées par des définitions explicites (le enummot - clé en lui-même ne provoque pas d'allocation de stockage) qui utilisent le enummot - clé et rappellent les définitions de struct et d' union :

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

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

enum cardsuit trump;

C expose la représentation entière des valeurs d'énumération directement au programmeur. Les entiers et les valeurs enum peuvent être mélangés librement, et toutes les opérations arithmétiques sur les valeurs enum sont autorisées. Il est même possible qu'une variable enum contienne un entier qui ne représente aucune des valeurs d'énumération. En fait, selon la définition du langage, le code ci-dessus définira Clubs, Diamonds, Hearts, et en Spadestant que constantes de type int, qui ne seront converties (silencieusement) que enum cardsuitsi elles sont stockées dans une variable de ce type.

C permet également au programmeur de choisir explicitement les valeurs des constantes d'énumération, même sans type. Par exemple,

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

pourrait être utilisé pour définir un type qui permet aux ensembles mathématiques de combinaisons d'être représentés enum cardsuitpar des opérations logiques au niveau du bit.

C#

Les types énumérés dans le langage de programmation C# préservent la plupart de la sémantique des « petits entiers » des énumérations C. Certaines opérations arithmétiques ne sont pas définies pour les enums, mais une valeur enum peut être explicitement convertie en entier et inversement, et une variable enum peut avoir des valeurs qui n'ont pas été déclarées par la définition enum. Par exemple, étant donné

enum Cardsuit
{
    Clubs,
    Diamonds,
    Spades,
    Hearts
}

les expressions CardSuit.Diamonds + 1et CardSuit.Hearts - CardSuit.Clubssont autorisées directement (parce qu'il peut être judicieux de parcourir la séquence de valeurs ou de demander combien d'étapes il y a entre deux valeurs), mais CardSuit.Hearts * CardSuit.Spadesest réputée avoir moins de sens et n'est autorisée que si les valeurs sont d'abord converties en nombres entiers .

C# fournit également la fonctionnalité de type C permettant de définir des valeurs entières spécifiques pour les énumérations. En faisant cela, il est possible d'effectuer des opérations binaires sur les énumérations, traitant ainsi les valeurs d'énumération comme des ensembles d'indicateurs. Ces indicateurs peuvent être testés à l'aide d'opérations binaires ou avec la méthode intégrée 'HasFlag' du type Enum.

La définition d'énumération définit des noms pour les valeurs entières sélectionnées et est syntaxique Sugar , car il est possible d'affecter à une variable enum d'autres valeurs entières qui ne sont pas dans la portée de la définition enum.

C++

C++ a des types d'énumération qui sont directement hérités du C et fonctionnent principalement comme ceux-ci, sauf qu'une énumération est un type réel en C++, donnant une vérification supplémentaire au moment de la compilation. De plus (comme pour les structs), le enummot-clé C++ est automatiquement combiné avec un typedef , de sorte qu'au lieu de nommer le type enum name, nommez-le simplement name. Cela peut être simulé en C en utilisant un typedef :typedef enum {Value1, Value2} name;

C++11 fournit un deuxième type d'énumération de type sécurisé qui n'est pas implicitement converti en un type entier. Il permet de définir le streaming io pour ce type. De plus, les énumérations ne fuient pas, elles doivent donc être utilisées avec Enumeration Type::enumeration. Ceci est spécifié par la phrase "enum class". Par exemple:

enum class Color {Red, Green, Blue};

Le type sous-jacent est un type intégral défini par l'implémentation qui est suffisamment grand pour contenir toutes les valeurs énumérées (il n'a pas besoin d'être le type le plus petit possible !). En C++, vous pouvez spécifier directement le type sous-jacent. Cela permet des "déclarations avancées" d'énumérations :

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.

Aller

Go utilise le iotamot - clé pour créer des constantes énumérées.

type ByteSize float64

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

Java

La version J2SE 5.0 du langage de programmation Java a ajouté des types énumérés dont la syntaxe de déclaration est similaire à celle de C :

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

Le système de types Java, cependant, traite les énumérations comme un type distinct des entiers, et le mélange des valeurs enum et entier n'est pas autorisé. En fait, un type enum en Java est en fait une classe spéciale générée par le compilateur plutôt qu'un type arithmétique, et les valeurs enum se comportent comme des instances globales pré-générées de cette classe. Les types d'énumération peuvent avoir des méthodes d'instance et un constructeur (dont les arguments peuvent être spécifiés séparément pour chaque valeur d'énumération). Tous les types enum étendent implicitement la Enumclasse abstraite. Un type enum ne peut pas être instancié directement.

En interne, chaque valeur enum contient un entier, correspondant à l'ordre dans lequel elles sont déclarées dans le code source, à partir de 0. Le programmeur ne peut pas définir directement un entier personnalisé pour une valeur enum, mais on peut définir des constructeurs surchargés qui peuvent ensuite affecter valeurs arbitraires aux membres auto-définis de la classe enum. Définir des getters permet ensuite d'accéder à ces membres auto-définis. L'entier interne peut être obtenu à partir d'une valeur enum à l'aide de la ordinal()méthode, et la liste des valeurs enum d'un type d'énumération peut être obtenue dans l'ordre à l'aide de la values()méthode. Il est généralement déconseillé aux programmeurs de convertir des énumérations en entiers et vice versa. Les types énumérés sont Comparable, utilisant l'entier interne ; en conséquence, ils peuvent être triés.

La bibliothèque standard Java fournit des classes utilitaires à utiliser avec les énumérations. La EnumSetclasse implémente une Setdes valeurs enum ; il est implémenté sous forme de tableau de bits , ce qui le rend très compact et aussi efficace que la manipulation explicite de bits, mais plus sûr. La EnumMapclasse implémente une Mapdes valeurs enum à l'objet. Il est implémenté sous forme de tableau, avec la valeur entière de la valeur enum servant d'index.

Perl

Les langages à typage dynamique dans la tradition syntaxique du C (par exemple, Perl ou JavaScript ) ne fournissent pas, en général, d'énumérations. Mais en programmation Perl, le même résultat peut être obtenu avec la liste des chaînes abrégées et les hachages (éventuellement des tranches ):

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

Raku (anciennement connu sous le nom de Perl 6) prend en charge les énumérations. Il existe plusieurs façons de déclarer des énumérations dans Raku, toutes créant une carte principale.

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

Les énumérations ont été ajoutées dans PHP version 8.1.

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

Rouiller

Bien que Rust utilise le enummot - clé comme C, il l'utilise pour décrire les unions étiquetées , dont les énumérations peuvent être considérées comme une forme dégénérée. Les énumérations de Rust sont donc beaucoup plus flexibles et peuvent contenir des variantes de structure et de tuple.

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

Rapide

En C, les énumérations attribuent des noms associés à un ensemble de valeurs entières. Dans Swift , les énumérations sont beaucoup plus flexibles et n'ont pas besoin de fournir une valeur pour chaque cas de l'énumération. Si une valeur (appelée valeur brute ) est fournie pour chaque cas d'énumération, la valeur peut être une chaîne, un caractère ou une valeur de tout type entier ou à virgule flottante.

Alternativement, les cas d'énumération peuvent spécifier des valeurs associées de tout type à stocker avec chaque valeur de cas différente, tout comme les unions ou les variantes le font dans d'autres langues. On peut définir un ensemble commun de cas liés dans le cadre d'une énumération, chacun ayant un ensemble différent de valeurs de types appropriés qui lui sont associés.

Dans Swift, les énumérations sont un type de première classe. Ils adoptent de nombreuses fonctionnalités traditionnellement prises en charge uniquement par les classes, telles que les propriétés calculées pour fournir des informations supplémentaires sur la valeur actuelle de l'énumération, et les méthodes d'instance pour fournir des fonctionnalités liées aux valeurs représentées par l'énumération. Les énumérations peuvent également définir des initialiseurs pour fournir une valeur de casse initiale et peuvent être étendues pour étendre leurs fonctionnalités au-delà de leur implémentation d'origine ; et peut se conformer aux protocoles pour fournir des fonctionnalités standard.

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

Contrairement à C et Objective-C , les cas d'énumération Swift ne reçoivent pas de valeur entière par défaut lors de leur création. Dans l'exemple CardSuit ci-dessus, les trèfles, les carreaux, les cœurs et les piques ne sont pas implicitement égaux à 0, 1, 2 et 3. Au lieu de cela, les différents cas d'énumération sont des valeurs à part entière, avec un type de CardSuit explicitement défini. .

Plusieurs cas peuvent apparaître sur une même ligne, séparés par des virgules :

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

Lorsque vous travaillez avec des énumérations qui stockent des valeurs brutes entières ou de chaîne, il n'est pas nécessaire d'attribuer explicitement une valeur brute pour chaque cas car Swift attribuera automatiquement les valeurs.

Par exemple, lorsque des entiers sont utilisés pour les valeurs brutes, la valeur implicite pour chaque cas est un de plus que le cas précédent. Si le premier cas n'a pas de valeur définie, sa valeur est 0.

L'énumération ci-dessous est un raffinement de l'énumération précédente de Planet, avec des valeurs brutes entières pour représenter l'ordre de chaque planète par rapport au soleil :

enum Planet: Int {
    case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
}

Dans l'exemple ci-dessus, Planet.mercury a une valeur brute explicite de 1, Planet.venus a une valeur brute implicite de 2, et ainsi de suite.

"Les détails se trouvent dans la documentation Swift en ligne ici."

Manuscrit

TypeScript ajoute un type de données 'enum' à JavaScript.

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

Par défaut, énumère le nombre de membres commençant à 0 ; cela peut être remplacé en définissant la valeur du premier :

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

Toutes les valeurs peuvent être réglées :

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

TypeScript prend en charge le mappage de la valeur numérique à son nom. Par exemple, cela trouve le nom de la valeur 2 :

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

alert(suitName);

Python

Un enummodule a été ajouté à la bibliothèque standard Python dans la version 3.4.

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

Il existe également une API fonctionnelle pour créer des énumérations avec des index générés automatiquement (commençant par un) :

Cards = Enum('Cards', 'CLUBS DIAMONDS HEARTS SPADES'])

Les énumérations Python n'imposent pas l'exactitude sémantique (une comparaison dénuée de sens avec une énumération incompatible renvoie toujours False plutôt que de lever une 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

Fortran

Fortran n'a que des types énumérés pour l'interopérabilité avec C ; par conséquent, la sémantique est similaire à C et, comme dans C, les valeurs d'énumération ne sont que des entiers et aucune autre vérification de type n'est effectuée. L'exemple C ci-dessus peut être écrit en Fortran comme

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

Visual Basic/VBA

Les types de données énumérés dans Visual Basic (jusqu'à la version 6) et VBA reçoivent automatiquement le Longtype de données " " et deviennent également eux-mêmes un type de données :

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

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

Exemple de code dans VB.NET

Enum CardSuit
    Clubs
    Diamonds
    Hearts
    Spades
End Enum

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

Zézayer

Common Lisp utilise le spécificateur de type de membre, par exemple,

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

qui indique que l'objet est de type cardsuit s'il s'agit d'un trèfle, d'un carreau #'eql, d'un cœur ou d'un pique. Cependant, le spécificateur de type de membre n'est pas valide en tant que spécialiste de paramètre CLOS ( Common Lisp Object System ). Au lieu de cela, (eql atom), qui est l'équivalent de (member atom)peut être utilisé (c'est-à-dire qu'un seul membre de l'ensemble peut être spécifié avec un spécificateur de type eql, cependant, il peut être utilisé comme un spécialiste de paramètre CLOS.) En d'autres termes, pour définir des méthodes pour couvrir un type énuméré, une méthode doit être définie pour chaque élément spécifique de ce type.

En outre,

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

peut être utilisé pour définir des types énumérés arbitraires au moment de l'exécution. Par exemple

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

ferait référence à un type équivalent à la définition précédente de cardsuit, car bien sûr aurait simplement utilisé

(member club diamond heart spade)

mais peut être moins déroutant avec la fonction #'memberpour des raisons stylistiques.

Type de données algébriques en programmation fonctionnelle

Dans les langages de programmation fonctionnels de la lignée ML (par exemple, Standard ML (SML), OCaml et Haskell ), un type de données algébrique avec uniquement des constructeurs nullaires peut être utilisé pour implémenter un type énuméré. Par exemple (dans la syntaxe des signatures SML) :

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

Dans ces langages, la représentation des petits entiers est complètement cachée au programmeur, si en effet une telle représentation est utilisée par l'implémentation. Cependant, Haskell a la Enum classe de type qu'un type peut dériver ou implémenter pour obtenir un mappage entre le type et Int.

Bases de données

Certaines bases de données prennent directement en charge les types énumérés. MySQL fournit un type énuméré ENUMavec des valeurs autorisées spécifiées sous forme de chaînes lorsqu'une table est créée. Les valeurs sont stockées sous forme d'index numériques avec la chaîne vide stockée sous forme de 0, la première valeur de chaîne stockée sous 1, la deuxième valeur de chaîne stockée sous forme de 2, etc. Les valeurs peuvent être stockées et récupérées sous forme d'index numériques ou de valeurs de chaîne.

Exemple:

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

Schéma XML

XML Schema prend en charge les types énumérés via la facette d'énumération utilisée pour contraindre la plupart des types de données primitifs tels que les chaînes.

<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>

Voir également

• Ensemble de contraste

Les références

Liens externes

• Types énumérés en C/C++
• Types énumérés en C#
• Types énumérés en Java
• Types énumérés dans MySQL
• Types énumérés dans Obix
• Types énumérés en XML
• Types énumérés en Visual Basic