JavaScript => Énumérations

Remarques

En programmation informatique, un type énuméré (également appelé enumeration ou enum [..]) est un type de données composé d’un ensemble de valeurs nommées appelées éléments, membres ou énumérateurs du type. Les noms des énumérateurs sont généralement des identificateurs qui se comportent comme des constantes dans le langage. Une variable qui a été déclarée comme ayant un type énuméré peut être affectée à l'un des énumérateurs en tant que valeur.
Wikipedia: type énuméré

JavaScript est faiblement typé, les variables ne sont pas déclarées avec un type au préalable et ne possèdent pas de type de données enum natif. Les exemples fournis ici peuvent inclure différentes manières de simuler des énumérateurs, des alternatives et des compromis possibles.

Enum définition en utilisant Object.freeze ()

5.1

JavaScript ne supporte pas directement les énumérateurs mais les fonctionnalités d'un énumérateur peuvent être imitées.

// Prevent the enum from being changed
const TestEnum = Object.freeze({
    One:1,
    Two:2,
    Three:3
});
// Define a variable with a value from the enum
var x = TestEnum.Two;
// Prints a value according to the variable's enum value
switch(x) {
    case TestEnum.One:
        console.log("111");
        break;

    case TestEnum.Two:
        console.log("222");
}

La définition d'énumération ci-dessus peut également être écrite comme suit:

var TestEnum = { One: 1, Two: 2, Three: 3 }
Object.freeze(TestEnum);

Après cela, vous pouvez définir une variable et imprimer comme avant.

Définition alternative

La méthode Object.freeze() est disponible depuis la version 5.1. Pour les anciennes versions, vous pouvez utiliser le code suivant (notez que cela fonctionne également dans les versions 5.1 et ultérieures):

var ColorsEnum = {
    WHITE: 0,
    GRAY: 1,
    BLACK: 2
}
// Define a variable with a value from the enum
var currentColor = ColorsEnum.GRAY;

Impression d'une variable enum

Après avoir défini une énumération de l'une des manières ci-dessus et défini une variable, vous pouvez imprimer la valeur de la variable ainsi que le nom correspondant à partir de l'énumération pour la valeur. Voici un exemple:

// Define the enum
var ColorsEnum = { WHITE: 0, GRAY: 1, BLACK: 2 }
Object.freeze(ColorsEnum);
// Define the variable and assign a value
var color = ColorsEnum.BLACK;
if(color == ColorsEnum.BLACK) {
   console.log(color);    // This will print "2"
   var ce = ColorsEnum;
   for (var name in ce) {
     if (ce[name] == ce.BLACK)
       console.log(name);    // This will print "BLACK"
   } 
}

Mise en œuvre des énumérations à l'aide de symboles

Comme ES6 a introduit les symboles , qui sont à la fois des valeurs primitives uniques et immuables pouvant être utilisées comme clé d'une propriété Object , au lieu d'utiliser des chaînes comme valeurs possibles pour une énumération, il est possible d'utiliser des symboles.

// Simple symbol
const newSymbol = Symbol();
typeof newSymbol === 'symbol' // true

// A symbol with a label
const anotherSymbol = Symbol("label");

// Each symbol is unique
const yetAnotherSymbol = Symbol("label");
yetAnotherSymbol === anotherSymbol; // false


const Regnum_Animale    = Symbol();
const Regnum_Vegetabile = Symbol();
const Regnum_Lapideum   = Symbol();

function describe(kingdom) {

  switch(kingdom) {

    case Regnum_Animale:
        return "Animal kingdom";
    case Regnum_Vegetabile:
        return "Vegetable kingdom";
    case Regnum_Lapideum:
        return "Mineral kingdom";
  }

}

describe(Regnum_Vegetabile);
// Vegetable kingdom

L'article Symboles dans ECMAScript 6 couvre ce nouveau type primitif plus en détail.

Valeur d'énumération automatique

5.1

Cet exemple montre comment attribuer automatiquement une valeur à chaque entrée d'une liste enum. Cela empêchera deux énumérations d'avoir la même valeur par erreur. REMARQUE: Prise en charge du navigateur Object.freeze

var testEnum = function() {
    // Initializes the enumerations
    var enumList = [
        "One",
        "Two",
        "Three"
    ];
    enumObj = {};
    enumList.forEach((item, index)=>enumObj[item] = index + 1); 
    
    // Do not allow the object to be changed
    Object.freeze(enumObj);
    return enumObj;
}();

console.log(testEnum.One); // 1 will be logged

var x = testEnum.Two;

switch(x) {
    case testEnum.One:
        console.log("111");
        break;

    case testEnum.Two:
        console.log("222"); // 222 will be logged
        break;
}

Modified text is an extract of the original Stack Overflow Documentation

Sous licence CC BY-SA 3.0

Non affilié à Stack Overflow

JavaScript
Énumérations

Recherche…