JavaScript => Enumeraciones

Observaciones

En la programación de computadoras, un tipo enumerado (también llamado enumeración o enumeración [..]) es un tipo de datos que consiste en un conjunto de valores denominados llamados elementos, miembros o enumeradores del tipo. Los nombres de los enumeradores suelen ser identificadores que se comportan como constantes en el idioma. A una variable que se ha declarado que tiene un tipo enumerado se le puede asignar cualquiera de los enumeradores como un valor.
Wikipedia: Tipo enumerado

JavaScript está mal escrito, las variables no se declaran con un tipo de antemano y no tiene un tipo de datos de enum nativo. Los ejemplos proporcionados aquí pueden incluir diferentes formas de simular enumeradores, alternativas y posibles compensaciones.

Definición de enumeración utilizando Object.freeze ()

5.1

JavaScript no es compatible directamente con los enumeradores, pero la funcionalidad de un enum puede ser imitada.

// 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 definición de enumeración anterior, también se puede escribir de la siguiente manera:

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

Después de eso puedes definir una variable e imprimir como antes.

Definición alternativa

El método Object.freeze() está disponible desde la versión 5.1. Para versiones anteriores, puede usar el siguiente código (tenga en cuenta que también funciona en las versiones 5.1 y posteriores):

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

Imprimir una variable enum

Después de definir una enumeración utilizando cualquiera de las formas anteriores y estableciendo una variable, puede imprimir tanto el valor de la variable como el nombre correspondiente de la enumeración para el valor. Aquí hay un ejemplo:

// 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"
   } 
}

Implementando Enums Usando Símbolos

A medida que ES6 introdujo los Símbolos , que son valores primarios únicos e inmutables que pueden usarse como la clave de una propiedad de Object , en lugar de usar cadenas como valores posibles para una enumeración, es posible usar símbolos.

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

El artículo Símbolos en ECMAScript 6 cubre este nuevo tipo primitivo con más detalle.

Valor de enumeración automática

5.1

Este ejemplo muestra cómo asignar automáticamente un valor a cada entrada en una lista de enumeración. Esto evitará que dos enumeraciones tengan el mismo valor por error. NOTA: Compatibilidad con el navegador 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

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

JavaScript
Enumeraciones

Buscar..