¿Cuál es la sintaxis preferida para definir enumeraciones en JavaScript? Algo como:

my.namespace.ColorEnum = {
    RED : 0,
    GREEN : 1,
    BLUE : 2
}

// later on

if(currentColor == my.namespace.ColorEnum.RED) {
   // whatever
}

¿O hay un idioma más preferible?

Desde 1.8.5 es posible sellar y congelar el objeto, así que defina lo anterior como:

const DaysEnum = Object.freeze({"monday":1, "tuesday":2, "wednesday":3, ...})

o

const DaysEnum = {"monday":1, "tuesday":2, "wednesday":3, ...}
Object.freeze(DaysEnum)

¡y voilá! JS enumeraciones.

Sin embargo, esto no le impide asignar un valor no deseado a una variable, que a menudo es el objetivo principal de las enumeraciones:

let day = DaysEnum.tuesday
day = 298832342 // goes through without any errors

Una forma de garantizar un mayor grado de seguridad de tipos (con enumeraciones o de otro tipo) es utilizar una herramienta como TypeScript o Flow .

Fuente

No se necesitan citas, pero las conservé para mantener la coherencia.

Esta no es una gran respuesta, pero yo diría que funciona bien, personalmente.

Habiendo dicho eso, dado que no importa cuáles sean los valores (ha usado 0, 1, 2), usaría una cadena significativa en caso de que alguna vez quisiera generar el valor actual.

ACTUALIZAR

Gracias por todos los votos a favor de todos, pero no creo que mi respuesta a continuación sea la mejor manera de escribir enumeraciones en JavaScript. Vea mi publicación de blog para más detalles: Enums en JavaScript .

Alertar el nombre ya es posible:

if (currentColor == my.namespace.ColorEnum.RED) {
   // alert name of currentColor (RED: 0)
   var col = my.namespace.ColorEnum;
   for (var name in col) {
     if (col[name] == col.RED)
       alert(name);
   }
}

Alternativamente, puede hacer que los valores sean objetos, para que pueda tener el pastel y comérselo también:

var SIZE = {
  SMALL : {value: 0, name: "Small", code: "S"}, 
  MEDIUM: {value: 1, name: "Medium", code: "M"}, 
  LARGE : {value: 2, name: "Large", code: "L"}
};

var currentSize = SIZE.MEDIUM;
if (currentSize == SIZE.MEDIUM) {
  // this alerts: "1: Medium"
  alert(currentSize.value + ": " + currentSize.name);
}

En JavaScript, como es un lenguaje dinámico, incluso es posible agregar valores de enumeración al conjunto más adelante:

// Add EXTRALARGE size
SIZE.EXTRALARGE = {value: 3, name: "Extra Large", code: "XL"};

Recuerde, los campos de la enumeración (valor, nombre y código en este ejemplo) no son necesarios para la verificación de identidad y solo están allí por conveniencia. Además, el nombre de la propiedad de tamaño en sí no necesita ser codificado, sino que también se puede establecer dinámicamente. Entonces, suponiendo que solo conozca el nombre de su nuevo valor de enumeración, aún puede agregarlo sin problemas:

// Add 'Extra Large' size, only knowing it's name
var name = "Extra Large";
SIZE[name] = {value: -1, name: name, code: "?"};

Por supuesto, esto significa que algunas suposiciones ya no se pueden hacer (ese valor representa el orden correcto para el tamaño, por ejemplo).

Recuerde, en JavaScript un objeto es como un mapa o una tabla hash . Un conjunto de pares nombre-valor. Puede recorrerlos o manipularlos sin saber de antemano mucho sobre ellos.

Ejemplo

for (var sz in SIZE) {
  // sz will be the names of the objects in SIZE, so
  // 'SMALL', 'MEDIUM', 'LARGE', 'EXTRALARGE'
  var size = SIZE[sz]; // Get the object mapped to the name in sz
  for (var prop in size) {
    // Get all the properties of the size object, iterates over
    // 'value', 'name' and 'code'. You can inspect everything this way.        
  }
} 

Y, por cierto, si está interesado en los espacios de nombres, puede echar un vistazo a mi solución para la administración de dependencias y espacios de nombres simples pero potentes para JavaScript: Paquetes JS

En pocas palabras: no puedes.

Puedes fingirlo, pero no obtendrás seguridad de tipografía. Normalmente, esto se hace creando un diccionario simple de valores de cadena asignados a valores enteros. Por ejemplo:

var DaysEnum = {"monday":1, "tuesday":2, "wednesday":3, ...}

Document.Write("Enumerant: " + DaysEnum.tuesday);

¿El problema con este enfoque? Puede redefinir accidentalmente su enumerante o accidentalmente tener valores de enumerador duplicados. Por ejemplo:

DaysEnum.monday = 4; // whoops, monday is now thursday, too

Editar

¿Qué pasa con la congelación de objetos de Artur Czajka? ¿No funcionaría eso para evitar que establezcas de lunes a jueves? - Fry Quad

Absolutamente, Object.freezesolucionaría totalmente el problema del que me quejé. Me gustaría recordarles a todos que cuando escribí lo anterior, Object.freezerealmente no existía.

Ahora ... ahora abre algunas posibilidades muy interesantes.

Edición 2
Aquí hay una muy buena biblioteca para crear enumeraciones.

http://www.2ality.com/2011/10/enums.html

Si bien es probable que no se ajuste a todos los usos válidos de enumeraciones, es muy útil.

Esto es lo que todos queremos:

function Enum(constantsList) {
    for (var i in constantsList) {
        this[constantsList[i]] = i;
    }
}

Ahora puedes crear tus enumeraciones:

var YesNo = new Enum(['NO', 'YES']);
var Color = new Enum(['RED', 'GREEN', 'BLUE']);

Al hacer esto, las constantes se pueden acceder de la manera habitual (Sí No, SÍ, Color.GREEN) y obtienen un valor int secuencial (NO = 0, YES = 1; ROJO = 0, VERDE = 1, AZUL = 2).

También puede agregar métodos, utilizando Enum.prototype:

Enum.prototype.values = function() {
    return this.allValues;
    /* for the above to work, you'd need to do
            this.allValues = constantsList at the constructor */
};

Editar - pequeña mejora - ahora con varargs: (desafortunadamente no funciona correctamente en IE: S ... entonces debería seguir con la versión anterior)

function Enum() {
    for (var i in arguments) {
        this[arguments[i]] = i;
    }
}

var YesNo = new Enum('NO', 'YES');
var Color = new Enum('RED', 'GREEN', 'BLUE');

En la mayoría de los navegadores modernos, hay un tipo de datos primitivo de símbolo que se puede usar para crear una enumeración. Garantizará la seguridad de tipo de la enumeración, ya que JavaScript garantiza que cada valor de símbolo sea único, es decir Symbol() != Symbol(). Por ejemplo:

const COLOR = Object.freeze({RED: Symbol(), BLUE: Symbol()});

Para simplificar la depuración, puede agregar una descripción a los valores de enumeración:

const COLOR = Object.freeze({RED: Symbol("RED"), BLUE: Symbol("BLUE")});

Demo de Plunker

En GitHub puede encontrar un contenedor que simplifica el código requerido para inicializar la enumeración:

const color = new Enum("RED", "BLUE")

color.RED.toString() // Symbol(RED)
color.getName(color.RED) // RED
color.size // 2
color.values() // Symbol(RED), Symbol(BLUE)
color.toString() // RED,BLUE

𝗣𝗹𝗮𝗶𝗻 𝗩𝗮𝗻𝗶𝗹𝗹𝗮𝗝𝗦 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲 𝗡𝗮𝗺𝗲𝘀

Veamos directamente el problema: tamaño del archivo. Todas las demás respuestas enumeradas aquí hinchan su código al extremo. Le presento que para obtener el mejor rendimiento posible, legibilidad del código, administración de proyectos a gran escala, sugerencias de sintaxis en muchos editores de código y reducción del tamaño del código por minificación, esta es la forma correcta de hacer enumeraciones: variables de notación de subrayado.

^wwwwwwwwww

Como se muestra en el cuadro anterior y en el ejemplo a continuación, aquí hay cinco pasos sencillos para comenzar:

1. Determine un nombre para el grupo de enumeración. Piense en un sustantivo que pueda describir el propósito de la enumeración o al menos las entradas en la enumeración. Por ejemplo, un grupo de enumeraciones que representan colores elegibles por el usuario podría denominarse mejor COLORCHOICES que COLORS.
2. Decida si las enumeraciones en el grupo son mutuamente excluyentes o independientes. Si se excluyen mutuamente, comience cada nombre de variable enumerado con ENUM_. Si es independiente o de lado a lado, useINDEX_ .
3. Para cada entrada, cree una nueva variable local cuyo nombre comience con ENUM_oINDEX_ , luego el nombre del grupo, luego un guión bajo y luego un nombre descriptivo único para la propiedad
4. Añada ENUMLENGTH_, ENUMLEN_, INDEXLENGTH_, o INDEXLEN_(si LEN_oLENGTH_ es preferencia personal) variables enumeradas al final. Debe usar esta variable siempre que sea posible en su código para asegurarse de que agregar una entrada adicional a la enumeración e incrementar este valor no rompa su código.
5. Dar cada variable enumerado sucesiva un valor uno más que el último, a partir de 0. Hay comentarios sobre esta página que digamos 0no debe ser utilizado como un valor enumerado porque 0 == null, 0 == false, 0 == "", y otra locura JS. Le presento que, para evitar este problema y aumentar el rendimiento al mismo tiempo, use siempre ===y nunca deje que ==aparezca en su código, excepto con typeof(ex typeof X == "string"). En todos mis años de uso ===, nunca he tenido un problema con el uso de 0 como valor de enumeración. Si todavía es aprensivo, 1podría usarse como valor inicial en ENUM_enumeraciones (pero no en INDEX_enumeraciones) sin penalización de rendimiento en muchos casos.

const ENUM_COLORENUM_RED   = 0;
const ENUM_COLORENUM_GREEN = 1;
const ENUM_COLORENUM_BLUE  = 2;
const ENUMLEN_COLORENUM    = 3;

// later on

if(currentColor === ENUM_COLORENUM_RED) {
   // whatever
}

Así es como recuerdo cuándo usarlo INDEX_y cuándo usarlo ENUM_:

// Precondition: var arr = []; //
arr[INDEX_] = ENUM_;

Sin embargo, ENUM_puede, en ciertas circunstancias, ser apropiado como un índice, como al contar las ocurrencias de cada elemento.

const ENUM_PET_CAT = 0,
      ENUM_PET_DOG = 1,
      ENUM_PET_RAT = 2,
      ENUMLEN_PET  = 3;

var favoritePets = [ENUM_PET_CAT, ENUM_PET_DOG, ENUM_PET_RAT,
                    ENUM_PET_DOG, ENUM_PET_DOG, ENUM_PET_CAT,
                    ENUM_PET_RAT, ENUM_PET_CAT, ENUM_PET_DOG];

var petsFrequency = [];

for (var i=0; i<ENUMLEN_PET; i=i+1|0)
  petsFrequency[i] = 0;

for (var i=0, len=favoritePets.length|0, petId=0; i<len; i=i+1|0)
  petsFrequency[petId = favoritePets[i]|0] = (petsFrequency[petId]|0) + 1|0;

console.log({
    "cat": petsFrequency[ENUM_PET_CAT],
    "dog": petsFrequency[ENUM_PET_DOG],
    "rat": petsFrequency[ENUM_PET_RAT]
});

Observe que, en el código anterior, es realmente fácil agregar un nuevo tipo de mascota: solo tendría que agregar una nueva entrada después ENUM_PET_RATy actualizar en ENUMLEN_PETconsecuencia. Puede ser más difícil y con errores agregar una nueva entrada en otros sistemas de enumeración.

^{No de lo que ... ... ¡... ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡...}

𝗘𝘅𝘁𝗲𝗻𝗱 𝗨𝗽𝗽𝗲𝗿𝗰𝗮𝘀𝗲 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀 𝗪𝗶𝘁𝗵 𝗔𝗱𝗱𝗶𝘁𝗶𝗼𝗻

Además, esta sintaxis de enumeraciones permite una clase clara y concisa que se extiende como se ve a continuación. Para extender una clase, agregue un número incremental a la LEN_entrada de la clase primaria. Luego, finalice la subclase con su propia LEN_entrada para que la subclase se pueda extender aún más en el futuro.

(function(window){
    "use strict";
    var parseInt = window.parseInt;

    // use INDEX_ when representing the index in an array instance
    const INDEX_PIXELCOLOR_TYPE = 0, // is a ENUM_PIXELTYPE
          INDEXLEN_PIXELCOLOR   = 1,
          INDEX_SOLIDCOLOR_R    = INDEXLEN_PIXELCOLOR+0,
          INDEX_SOLIDCOLOR_G    = INDEXLEN_PIXELCOLOR+1,
          INDEX_SOLIDCOLOR_B    = INDEXLEN_PIXELCOLOR+2,
          INDEXLEN_SOLIDCOLOR   = INDEXLEN_PIXELCOLOR+3,
          INDEX_ALPHACOLOR_R    = INDEXLEN_PIXELCOLOR+0,
          INDEX_ALPHACOLOR_G    = INDEXLEN_PIXELCOLOR+1,
          INDEX_ALPHACOLOR_B    = INDEXLEN_PIXELCOLOR+2,
          INDEX_ALPHACOLOR_A    = INDEXLEN_PIXELCOLOR+3,
          INDEXLEN_ALPHACOLOR   = INDEXLEN_PIXELCOLOR+4,
    // use ENUM_ when representing a mutually-exclusive species or type
          ENUM_PIXELTYPE_SOLID = 0,
          ENUM_PIXELTYPE_ALPHA = 1,
          ENUM_PIXELTYPE_UNKNOWN = 2,
          ENUMLEN_PIXELTYPE    = 2;

    function parseHexColor(inputString) {
        var rawstr = inputString.trim().substring(1);
        var result = [];
        if (rawstr.length === 8) {
            result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_ALPHA;
            result[INDEX_ALPHACOLOR_R] = parseInt(rawstr.substring(0,2), 16);
            result[INDEX_ALPHACOLOR_G] = parseInt(rawstr.substring(2,4), 16);
            result[INDEX_ALPHACOLOR_B] = parseInt(rawstr.substring(4,6), 16);
            result[INDEX_ALPHACOLOR_A] = parseInt(rawstr.substring(4,6), 16);
        } else if (rawstr.length === 4) {
            result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_ALPHA;
            result[INDEX_ALPHACOLOR_R] = parseInt(rawstr[0], 16) * 0x11;
            result[INDEX_ALPHACOLOR_G] = parseInt(rawstr[1], 16) * 0x11;
            result[INDEX_ALPHACOLOR_B] = parseInt(rawstr[2], 16) * 0x11;
            result[INDEX_ALPHACOLOR_A] = parseInt(rawstr[3], 16) * 0x11;
        } else if (rawstr.length === 6) {
            result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_SOLID;
            result[INDEX_SOLIDCOLOR_R] = parseInt(rawstr.substring(0,2), 16);
            result[INDEX_SOLIDCOLOR_G] = parseInt(rawstr.substring(2,4), 16);
            result[INDEX_SOLIDCOLOR_B] = parseInt(rawstr.substring(4,6), 16);
        } else if (rawstr.length === 3) {
            result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_SOLID;
            result[INDEX_SOLIDCOLOR_R] = parseInt(rawstr[0], 16) * 0x11;
            result[INDEX_SOLIDCOLOR_G] = parseInt(rawstr[1], 16) * 0x11;
            result[INDEX_SOLIDCOLOR_B] = parseInt(rawstr[2], 16) * 0x11;
        } else {
            result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_UNKNOWN;
        }
        return result;
    }

    // the red component of green
    console.log(parseHexColor("#0f0")[INDEX_SOLIDCOLOR_R]);
    // the alpha of transparent purple
    console.log(parseHexColor("#f0f7")[INDEX_ALPHACOLOR_A]); 
    // the enumerated array for turquoise
    console.log(parseHexColor("#40E0D0"));
})(self);

(Longitud: 2,450 bytes)

Algunos pueden decir que esto es menos práctico que otras soluciones: quita toneladas de espacio, lleva mucho tiempo escribir y no está recubierto con sintaxis de azúcar. Esas personas tendrían razón si no minimizan su código. Sin embargo, ninguna persona razonable dejaría un código sin minificar en el producto final. Para esta minificación, Closure Compiler es lo mejor que todavía tengo que encontrar. El acceso en línea se puede encontrar aquí . El compilador de cierre puede tomar todos estos datos de enumeración e incorporarlos, lo que hace que su Javascript sea súper pequeño y se ejecute súper rápido. Por lo tanto, Minify with Closure Compiler. Observar.

^{No de lo que ... ... ¡... ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡...}

𝗠𝗶𝗻𝗶𝗳𝘆 𝗪𝗶𝘁𝗵 𝗖𝗹𝗼𝘀𝘂𝗿𝗲 𝗖𝗼𝗺𝗽𝗶𝗹𝗲𝗿

El compilador de cierre puede realizar algunas optimizaciones bastante increíbles a través de inferencias que están mucho más allá de las capacidades de cualquier otro minificador de Javascript. Closure Compiler es capaz de incorporar variables primitivas en un valor fijo. Closure Compiler también puede hacer inferencias basadas en estos valores en línea y eliminar bloques no utilizados en sentencias if y bucles.

'use strict';(function(e){function d(a){a=a.trim().substring(1);var b=[];8===a.length?(b[0]=1,b[1]=c(a.substring(0,2),16),b[2]=c(a.substring(2,4),16),b[3]=c(a.substring(4,6),16),b[4]=c(a.substring(4,6),16)):4===a.length?(b[1]=17*c(a[0],16),b[2]=17*c(a[1],16),b[3]=17*c(a[2],16),b[4]=17*c(a[3],16)):6===a.length?(b[0]=0,b[1]=c(a.substring(0,2),16),b[2]=c(a.substring(2,4),16),b[3]=c(a.substring(4,6),16)):3===a.length?(b[0]=0,b[1]=17*c(a[0],16),b[2]=17*c(a[1],16),b[3]=17*c(a[2],16)):b[0]=2;return b}var c=
e.parseInt;console.log(d("#0f0")[1]);console.log(d("#f0f7")[4]);console.log(d("#40E0D0"))})(self);

(Longitud: 605 bytes)

Closure Compiler lo recompensa por codificar de manera más inteligente y organizar bien su código porque, mientras que muchos minificadores castigan el código organizado con un tamaño de archivo minificado más grande, Closure Compiler puede filtrar toda su limpieza y cordura para generar un tamaño de archivo aún más pequeño si usa trucos como enumeraciones de nombres de variables. Eso, en esta mente, es el santo grial de la codificación: una herramienta que ayuda tanto a su código con un tamaño reducido más pequeño como a su mente al entrenar mejores hábitos de programación.

^{No de lo que ... ... ¡... ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡...}

𝗦𝗺𝗮𝗹𝗹𝗲𝗿 𝗖𝗼𝗱𝗲 𝗦𝗶𝘇𝗲

Ahora, veamos qué tan grande sería el archivo equivalente sin ninguna de estas enumeraciones.

Origen sin usar enumeraciones (longitud: 1,973 bytes (¡477 bytes más corto que el código enumerado!))
Minificado sin usar enumeraciones (longitud: 843 bytes (238 bytes más que el código enumerado ))

Como se ve, sin enumeraciones, el código fuente es más corto a costa de un código minificado más grande. No sé sobre ti; pero estoy seguro de que no incorporo el código fuente en el producto final. Por lo tanto, esta forma de enumeración es muy superior en la medida en que da como resultado tamaños de archivo minificados más pequeños.

^{No de lo que ... ... ¡... ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡...}

𝗖𝗼𝗼𝗽𝗲𝗿𝗮𝘁𝗶𝘃𝗲 🤝 𝗕𝘂𝗴 𝗙𝗶𝘅𝗶𝗻𝗴

Otra ventaja de esta forma de enumeración es que se puede usar para administrar fácilmente proyectos a gran escala sin sacrificar el tamaño de código minimizado. Cuando se trabaja en un proyecto grande con muchas otras personas, puede ser beneficioso marcar y etiquetar explícitamente los nombres de las variables con quién creó el código para que el creador original del código pueda identificarse rápidamente para la corrección colaborativa de errores.

// JG = Jack Giffin
const ENUM_JG_COLORENUM_RED   = 0,
      ENUM_JG_COLORENUM_GREEN = 1,
      ENUM_JG_COLORENUM_BLUE  = 2,
      ENUMLEN_JG_COLORENUM    = 3;

// later on

if(currentColor === ENUM_JG_COLORENUM_RED) {
   // whatever
}

// PL = Pepper Loftus
// BK = Bob Knight
const ENUM_PL_ARRAYTYPE_UNSORTED   = 0,
      ENUM_PL_ARRAYTYPE_ISSORTED   = 1,
      ENUM_BK_ARRAYTYPE_CHUNKED    = 2, // added by Bob Knight
      ENUM_JG_ARRAYTYPE_INCOMPLETE = 3, // added by jack giffin
      ENUMLEN_PL_COLORENUM         = 4;

// later on

if(
  randomArray === ENUM_PL_ARRAYTYPE_UNSORTED ||
  randomArray === ENUM_BK_ARRAYTYPE_CHUNKED
) {
   // whatever
}

𝗦𝘂𝗽𝗲𝗿𝗶𝗼𝗿 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲

Además, esta forma de enumeración también es mucho más rápida después de la minificación. En las propiedades con nombre normal, el navegador tiene que usar hashmaps para buscar dónde está la propiedad en el objeto. Aunque los compiladores JIT almacenan en caché de forma inteligente esta ubicación en el objeto, todavía hay una sobrecarga tremenda debido a casos especiales como la eliminación de una propiedad inferior del objeto.

Pero, con arreglos PACKED_ELEMENTS indexados enteros no dispersos continuos , el navegador puede omitir gran parte de esa sobrecarga porque el índice del valor en el arreglo interno ya está especificado. Sí, de acuerdo con el estándar ECMAScript, se supone que todas las propiedades deben tratarse como cadenas. Sin embargo, este aspecto del estándar ECMAScript es muy engañoso sobre el rendimiento porque todos los navegadores tienen optimizaciones especiales para índices numéricos en matrices.

/// Hashmaps are slow, even with JIT juice
var ref = {};
ref.count = 10;
ref.value = "foobar";

Compare el código de arriba con el código de abajo.

/// Arrays, however, are always lightning fast
const INDEX_REFERENCE_COUNT = 0;
const INDEX_REFERENCE_VALUE = 1;
const INDEXLENGTH_REFERENCE = 2;

var ref = [];
ref[INDEX_REFERENCE_COUNT] = 10;
ref[INDEX_REFERENCE_VALUE] = "foobar";

Uno podría objetar el código con enumeraciones que parecen ser mucho más largas que el código con objetos ordinarios, pero la apariencia puede ser engañosa. Es importante recordar que el tamaño del código fuente no es proporcional al tamaño de salida cuando se utiliza el compilador de cierre épico. Observar.

/// Hashmaps are slow, even with JIT juice
var a={count:10,value:"foobar"};

El código minificado sin enumeraciones está arriba y el código minificado con enumeraciones está abajo.

/// Arrays, however, are always lightning fast
var a=[10,"foobar"];

El ejemplo anterior demuestra que, además de tener un rendimiento superior, el código enumerado también da como resultado un tamaño de archivo minimizado más pequeño.

^{No de lo que ... ... ¡... ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡...}

𝗘𝗮𝘀𝘆 𝗗𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴

Además, la cereza personal de este en la parte superior está utilizando esta forma de enumeraciones junto con el editor de texto CodeMirror en modo Javascript. El modo de resaltado de sintaxis Javascript de CodeMirror resalta las variables locales en el alcance actual. De esa manera, usted sabe instantáneamente cuando escribe un nombre de variable correctamente porque si el nombre de la variable se declaró previamente con la excepción al ejecutar código con nombres de enumeración mal escritos. Además, las herramientas de JavaScript, como JSLint y Closure Compiler, son muy ruidosas al decirle cuando escribe incorrectamente en un nombre de variable de enumeración. CodeMirror, el navegador y varias herramientas de Javascript juntas hacen que la depuración de esta forma de enumeración sea muy simple y realmente fácil.var palabra clave, entonces el nombre de la variable cambiará a un color especial (cian por defecto). Incluso si no utiliza CodeMirror, al menos el navegador arroja un útil[variable name] is not defined

const ENUM_COLORENUM_RED   = 0,
      ENUM_COLORENUM_GREEN = 1,
      ENUM_COLORENUM_BLUE  = 2,
      ENUMLEN_COLORENUM    = 3;
var currentColor = ENUM_COLORENUM_GREEN;

if(currentColor === ENUM_COLORENUM_RED) {
   // whatever
}

if(currentColor === ENUM_COLORENUM_DNE) {
   // whatever
}

En el fragmento anterior, se le alertó con un error porque ENUM_COLORENUM_DNEno existe.

^{No de lo que ... ... ¡... ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡...}

𝗖𝗼𝗻𝗰𝗹𝘂𝘀𝗶𝗼𝗻 ☑

Creo que es seguro decir que esta metodología de enumeración es, de hecho, la mejor manera de ir no solo para el tamaño de código minimizado, sino también para el rendimiento, la depuración y la colaboración.

^{Después de leer una pregunta útil, agradezco al autor por dedicar tiempo a su escritura haciendo clic en la flecha superior izquierda hacia arriba en el cuadro de preguntas. Cada cuadro de respuesta también tiene una de estas flechas hacia arriba.}

He estado jugando con esto, ya que amo mis enumeraciones. =)

Usando Object.definePropertycreo que se me ocurrió una solución algo viable.

Aquí hay un jsfiddle: http://jsfiddle.net/ZV4A6/

Usando este método ... debería (en teoría) poder llamar y definir valores de enumeración para cualquier objeto, sin afectar otros atributos de ese objeto.

Object.defineProperty(Object.prototype,'Enum', {
    value: function() {
        for(i in arguments) {
            Object.defineProperty(this,arguments[i], {
                value:parseInt(i),
                writable:false,
                enumerable:true,
                configurable:true
            });
        }
        return this;
    },
    writable:false,
    enumerable:false,
    configurable:false
}); 

Debido al atributo, writable:falseesto debería hacer que sea seguro.

Por lo tanto, debería poder crear un objeto personalizado y luego invocarlo Enum(). Los valores asignados comienzan en 0 y se incrementan por elemento.

var EnumColors={};
EnumColors.Enum('RED','BLUE','GREEN','YELLOW');
EnumColors.RED;    // == 0
EnumColors.BLUE;   // == 1
EnumColors.GREEN;  // == 2
EnumColors.YELLOW; // == 3

Usar proxies Javascript

TLDR: agregue esta clase a sus métodos de utilidad y úsela en todo su código, se burla del comportamiento de Enum de los lenguajes de programación tradicionales y en realidad arroja errores cuando intenta acceder a un enumerador que no existe o agregar / actualizar un enumerador. No hay necesidad de confiar Object.freeze().

class Enum {
  constructor(enumObj) {
    const handler = {
      get(target, name) {
        if (typeof target[name] != 'undefined') {
          return target[name];
        }
        throw new Error(`No such enumerator: ${name}`);
      },
      set() {
        throw new Error('Cannot add/update properties on an Enum instance after it is defined')
      }
    };

    return new Proxy(enumObj, handler);
  }
}

Luego cree enumeraciones instanciando la clase:

const roles = new Enum({
  ADMIN: 'Admin',
  USER: 'User',
});

Explicación completa:

Una característica muy beneficiosa de Enums que obtienes de los idiomas tradicionales es que explotan (arrojan un error en tiempo de compilación) si intentas acceder a un enumerador que no existe.

Además de congelar la estructura de enumeración burlada para evitar que se agreguen valores adicionales accidental / maliciosamente, ninguna de las otras respuestas aborda esa característica intrínseca de Enums.

Como probablemente sepa, acceder a miembros no existentes en JavaScript simplemente devuelve undefinedy no explota su código. Como los enumeradores son constantes predefinidas (es decir, días de la semana), nunca debería haber un caso en el que un enumerador no esté definido.

No me malinterpreten, el comportamiento de JavaScript de regresar undefinedal acceder a propiedades indefinidas es en realidad una característica muy poderosa del lenguaje, pero no es una característica que desea cuando intenta burlarse de las estructuras tradicionales de Enum.

Aquí es donde brillan los objetos proxy. Los proxies se estandarizaron en el lenguaje con la introducción de ES6 (ES2015). Aquí está la descripción de MDN:

El objeto Proxy se usa para definir comportamientos personalizados para operaciones fundamentales (por ejemplo, búsqueda de propiedades, asignación, enumeración, invocación de funciones, etc.).

De manera similar a un proxy de servidor web, los proxys de JavaScript pueden interceptar operaciones en objetos (con el uso de "trampas", llámelos ganchos si lo desea) y le permiten realizar varias comprobaciones, acciones y / o manipulaciones antes de que se completen (o en algunos casos, detener por completo las operaciones, que es exactamente lo que queremos hacer si tratamos de hacer referencia a un enumerador que no existe).

Aquí hay un ejemplo artificial que usa el objeto Proxy para imitar Enums. Los enumeradores en este ejemplo son métodos HTTP estándar (es decir, "GET", "POST", etc.):

// Class for creating enums (13 lines)
// Feel free to add this to your utility library in 
// your codebase and profit! Note: As Proxies are an ES6 
// feature, some browsers/clients may not support it and 
// you may need to transpile using a service like babel

class Enum {
  // The Enum class instantiates a JavaScript Proxy object.
  // Instantiating a `Proxy` object requires two parameters, 
  // a `target` object and a `handler`. We first define the handler,
  // then use the handler to instantiate a Proxy.

  // A proxy handler is simply an object whose properties
  // are functions which define the behavior of the proxy 
  // when an operation is performed on it. 
  
  // For enums, we need to define behavior that lets us check what enumerator
  // is being accessed and what enumerator is being set. This can be done by 
  // defining "get" and "set" traps.
  constructor(enumObj) {
    const handler = {
      get(target, name) {
        if (typeof target[name] != 'undefined') {
          return target[name]
        }
        throw new Error(`No such enumerator: ${name}`)
      },
      set() {
        throw new Error('Cannot add/update properties on an Enum instance after it is defined')
      }
    }


    // Freeze the target object to prevent modifications
    return new Proxy(enumObj, handler)
  }
}


// Now that we have a generic way of creating Enums, lets create our first Enum!
const httpMethods = new Enum({
  DELETE: "DELETE",
  GET: "GET",
  OPTIONS: "OPTIONS",
  PATCH: "PATCH",
  POST: "POST",
  PUT: "PUT"
})

// Sanity checks
console.log(httpMethods.DELETE)
// logs "DELETE"

try {
  httpMethods.delete = "delete"
} catch (e) {
console.log("Error: ", e.message)
}
// throws "Cannot add/update properties on an Enum instance after it is defined"

try {
  console.log(httpMethods.delete)
} catch (e) {
  console.log("Error: ", e.message)
}
// throws "No such enumerator: delete"

Aparte: ¿Qué diablos es un proxy?

Recuerdo que cuando comencé a ver la palabra proxy en todas partes, definitivamente no tenía sentido para mí por mucho tiempo. Si ese es usted en este momento, creo que una forma fácil de generalizar proxies es pensar en ellos como software, instituciones o incluso personas que actúan como intermediarios o intermediarios entre dos servidores, empresas o personas.

Este es uno antiguo que conozco, pero la forma en que se ha implementado a través de la interfaz TypeScript es:

var MyEnum;
(function (MyEnum) {
    MyEnum[MyEnum["Foo"] = 0] = "Foo";
    MyEnum[MyEnum["FooBar"] = 2] = "FooBar";
    MyEnum[MyEnum["Bar"] = 1] = "Bar";
})(MyEnum|| (MyEnum= {}));

Esto le permite buscar tanto en lo MyEnum.Barque devuelve 1 como en lo MyEnum[1]que devuelve "Barra" independientemente del orden de la declaración.

En ES7 , puede hacer un ENUM elegante basándose en atributos estáticos:

class ColorEnum  {
    static RED = 0 ;
    static GREEN = 1;
    static BLUE = 2;
}

entonces

if (currentColor === ColorEnum.GREEN ) {/*-- coding --*/}

La ventaja (de usar la clase en lugar del objeto literal) es tener una clase principal, Enumentonces todas las enumeraciones extenderán esa clase.

 class ColorEnum  extends Enum {/*....*/}

Esta es la solución que uso.

function Enum() {
    this._enums = [];
    this._lookups = {};
}

Enum.prototype.getEnums = function() {
    return _enums;
}

Enum.prototype.forEach = function(callback){
    var length = this._enums.length;
    for (var i = 0; i < length; ++i){
        callback(this._enums[i]);
    }
}

Enum.prototype.addEnum = function(e) {
    this._enums.push(e);
}

Enum.prototype.getByName = function(name) {
    return this[name];
}

Enum.prototype.getByValue = function(field, value) {
    var lookup = this._lookups[field];
    if(lookup) {
        return lookup[value];
    } else {
        this._lookups[field] = ( lookup = {});
        var k = this._enums.length - 1;
        for(; k >= 0; --k) {
            var m = this._enums[k];
            var j = m[field];
            lookup[j] = m;
            if(j == value) {
                return m;
            }
        }
    }
    return null;
}

function defineEnum(definition) {
    var k;
    var e = new Enum();
    for(k in definition) {
        var j = definition[k];
        e[k] = j;
        e.addEnum(j)
    }
    return e;
}

Y define sus enumeraciones de esta manera:

var COLORS = defineEnum({
    RED : {
        value : 1,
        string : 'red'
    },
    GREEN : {
        value : 2,
        string : 'green'
    },
    BLUE : {
        value : 3,
        string : 'blue'
    }
});

Y así es como accedes a tus enumeraciones:

COLORS.BLUE.string
COLORS.BLUE.value
COLORS.getByName('BLUE').string
COLORS.getByValue('value', 1).string

COLORS.forEach(function(e){
    // do what you want with e
});

Usualmente uso los últimos 2 métodos para mapear enumeraciones de objetos de mensaje.

Algunas ventajas de este enfoque:

• Enums fáciles de declarar
• Fácil acceso a tus enumeraciones
• Tus enumeraciones pueden ser tipos complejos
• La clase Enum tiene algo de almacenamiento en caché asociativo si usa mucho getByValue

Algunas desventajas:

• Hay algo de administración de memoria desordenada, ya que mantengo las referencias a las enumeraciones
• Todavía no hay seguridad de tipo

Crear un objeto literal:

const Modes = {
  DRAGGING: 'drag',
  SCALING:  'scale',
  CLICKED:  'click'
};

Si está utilizando Backbone , puede obtener una funcionalidad de enumeración completa (buscar por id, nombre, miembros personalizados) de forma gratuita mediante Backbone.Collection .

// enum instance members, optional
var Color = Backbone.Model.extend({
    print : function() {
        console.log("I am " + this.get("name"))
    }
});

// enum creation
var Colors = new Backbone.Collection([
    { id : 1, name : "Red", rgb : 0xFF0000},
    { id : 2, name : "Green" , rgb : 0x00FF00},
    { id : 3, name : "Blue" , rgb : 0x0000FF}
], {
    model : Color
});

// Expose members through public fields.
Colors.each(function(color) {
    Colors[color.get("name")] = color;
});

// using
Colors.Red.print()

tus respuestas son demasiado complicadas

var buildSet = function(array) {
  var set = {};
  for (var i in array) {
    var item = array[i];
    set[item] = item;
  }
  return set;
}

var myEnum = buildSet(['RED','GREEN','BLUE']);
// myEnum.RED == 'RED' ...etc

He modificado la solución de Andre 'Fi':

  function Enum() {
    var that = this;
    for (var i in arguments) {
        that[arguments[i]] = i;
    }
    this.name = function(value) {
        for (var key in that) {
            if (that[key] == value) {
                return key;
            }
        }
    };
    this.exist = function(value) {
        return (typeof that.name(value) !== "undefined");
    };
    if (Object.freeze) {
        Object.freeze(that);
    }
  }

Prueba:

var Color = new Enum('RED', 'GREEN', 'BLUE');
undefined
Color.name(Color.REDs)
undefined
Color.name(Color.RED)
"RED"
Color.exist(Color.REDs)
false
Color.exist(Color.RED)
true

Se me ocurrió este enfoque, que se basa en las enumeraciones en Java. Estos son de tipo seguro, por lo que también puede realizar instanceofverificaciones.

Puede definir enumeraciones como esta:

var Days = Enum.define("Days", ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]);

Daysahora se refiere a la Daysenumeración:

Days.Monday instanceof Days; // true

Days.Friday.name(); // "Friday"
Days.Friday.ordinal(); // 4

Days.Sunday === Days.Sunday; // true
Days.Sunday === Days.Friday; // false

Days.Sunday.toString(); // "Sunday"

Days.toString() // "Days { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday } "

Days.values().map(function(e) { return e.name(); }); //["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
Days.values()[4].name(); //"Friday"

Days.fromName("Thursday") === Days.Thursday // true
Days.fromName("Wednesday").name() // "Wednesday"
Days.Friday.fromName("Saturday").name() // "Saturday"

La implementación:

var Enum = (function () {
    /**
     * Function to define an enum
     * @param typeName - The name of the enum.
     * @param constants - The constants on the enum. Can be an array of strings, or an object where each key is an enum
     * constant, and the values are objects that describe attributes that can be attached to the associated constant.
     */
    function define(typeName, constants) {

        /** Check Arguments **/
        if (typeof typeName === "undefined") {
            throw new TypeError("A name is required.");
        }

        if (!(constants instanceof Array) && (Object.getPrototypeOf(constants) !== Object.prototype)) {

            throw new TypeError("The constants parameter must either be an array or an object.");

        } else if ((constants instanceof Array) && constants.length === 0) {

            throw new TypeError("Need to provide at least one constant.");

        } else if ((constants instanceof Array) && !constants.reduce(function (isString, element) {
                return isString && (typeof element === "string");
            }, true)) {

            throw new TypeError("One or more elements in the constant array is not a string.");

        } else if (Object.getPrototypeOf(constants) === Object.prototype && !Object.keys(constants).reduce(function (isObject, constant) {
                return Object.getPrototypeOf(constants[constant]) === Object.prototype;
            }, true)) {

            throw new TypeError("One or more constants do not have an associated object-value.");

        }

        var isArray = (constants instanceof Array);
        var isObject = !isArray;

        /** Private sentinel-object used to guard enum constructor so that no one else can create enum instances **/
        function __() { };

        /** Dynamically define a function with the same name as the enum we want to define. **/
        var __enum = new Function(["__"],
            "return function " + typeName + "(sentinel, name, ordinal) {" +
                "if(!(sentinel instanceof __)) {" +
                    "throw new TypeError(\"Cannot instantiate an instance of " + typeName + ".\");" +
                "}" +

                "this.__name = name;" +
                "this.__ordinal = ordinal;" +
            "}"
        )(__);

        /** Private objects used to maintain enum instances for values(), and to look up enum instances for fromName() **/
        var __values = [];
        var __dict = {};

        /** Attach values() and fromName() methods to the class itself (kind of like static methods). **/
        Object.defineProperty(__enum, "values", {
            value: function () {
                return __values;
            }
        });

        Object.defineProperty(__enum, "fromName", {
            value: function (name) {
                var __constant = __dict[name]
                if (__constant) {
                    return __constant;
                } else {
                    throw new TypeError(typeName + " does not have a constant with name " + name + ".");
                }
            }
        });

        /**
         * The following methods are available to all instances of the enum. values() and fromName() need to be
         * available to each constant, and so we will attach them on the prototype. But really, they're just
         * aliases to their counterparts on the prototype.
         */
        Object.defineProperty(__enum.prototype, "values", {
            value: __enum.values
        });

        Object.defineProperty(__enum.prototype, "fromName", {
            value: __enum.fromName
        });

        Object.defineProperty(__enum.prototype, "name", {
            value: function () {
                return this.__name;
            }
        });

        Object.defineProperty(__enum.prototype, "ordinal", {
            value: function () {
                return this.__ordinal;
            }
        });

        Object.defineProperty(__enum.prototype, "valueOf", {
            value: function () {
                return this.__name;
            }
        });

        Object.defineProperty(__enum.prototype, "toString", {
            value: function () {
                return this.__name;
            }
        });

        /**
         * If constants was an array, we can the element values directly. Otherwise, we will have to use the keys
         * from the constants object.
         */
        var _constants = constants;
        if (isObject) {
            _constants = Object.keys(constants);
        }

        /** Iterate over all constants, create an instance of our enum for each one, and attach it to the enum type **/
        _constants.forEach(function (name, ordinal) {
            // Create an instance of the enum
            var __constant = new __enum(new __(), name, ordinal);

            // If constants was an object, we want to attach the provided attributes to the instance.
            if (isObject) {
                Object.keys(constants[name]).forEach(function (attr) {
                    Object.defineProperty(__constant, attr, {
                        value: constants[name][attr]
                    });
                });
            }

            // Freeze the instance so that it cannot be modified.
            Object.freeze(__constant);

            // Attach the instance using the provided name to the enum type itself.
            Object.defineProperty(__enum, name, {
                value: __constant
            });

            // Update our private objects
            __values.push(__constant);
            __dict[name] = __constant;
        });

        /** Define a friendly toString method for the enum **/
        var string = typeName + " { " + __enum.values().map(function (c) {
                return c.name();
            }).join(", ") + " } ";

        Object.defineProperty(__enum, "toString", {
            value: function () {
                return string;
            }
        });

        /** Freeze our private objects **/
        Object.freeze(__values);
        Object.freeze(__dict);

        /** Freeze the prototype on the enum and the enum itself **/
        Object.freeze(__enum.prototype);
        Object.freeze(__enum);

        /** Return the enum **/
        return __enum;
    }

    return {
        define: define
    }

})();

IE8 no es compatible con el método freeze ().
Fuente: http://kangax.github.io/compat-table/es5/ , haga clic en "¿Mostrar navegadores obsoletos?" en la parte superior y verifique IE8 y congele la intersección de la fila de columnas.

En mi proyecto de juego actual, lo he usado a continuación, ya que pocos clientes aún usan IE8:

var CONST_WILD_TYPES = {
    REGULAR: 'REGULAR',
    EXPANDING: 'EXPANDING',
    STICKY: 'STICKY',
    SHIFTING: 'SHIFTING'
};

También podríamos hacer:

var CONST_WILD_TYPES = {
    REGULAR: 'RE',
    EXPANDING: 'EX',
    STICKY: 'ST',
    SHIFTING: 'SH'
};

o incluso esto:

var CONST_WILD_TYPES = {
    REGULAR: '1',
    EXPANDING: '2',
    STICKY: '3',
    SHIFTING: '4'
};

El último, parece más eficiente para la cadena, reduce su ancho de banda total si tiene un servidor y un cliente que intercambian estos datos.
Por supuesto, ahora es su deber asegurarse de que no haya conflictos en los datos (RE, EX, etc. deben ser únicos, también 1, 2, etc. deben ser únicos). Tenga en cuenta que debe mantenerlos para siempre para la compatibilidad con versiones anteriores.

Asignación:

var wildType = CONST_WILD_TYPES.REGULAR;

Comparacion:

if (wildType === CONST_WILD_TYPES.REGULAR) {
    // do something here
}

var ColorEnum = {
    red: {},
    green: {},
    blue: {}
}

No necesita asegurarse de no asignar números duplicados a diferentes valores de enumeración de esta manera. Un nuevo objeto se instancia y se asigna a todos los valores de enumeración.

Aquí hay un par de formas diferentes de implementar enumeraciones TypeScript .

La forma más fácil es simplemente iterar sobre un objeto, agregando pares clave-valor invertidos al objeto. El único inconveniente es que debe establecer manualmente el valor para cada miembro.

function _enum(list) {       
  for (var key in list) {
    list[list[key] = list[key]] = key;
  }
  return Object.freeze(list);
}

var Color = _enum({
  Red: 0,
  Green: 5,
  Blue: 2
});

// Color → {0: "Red", 2: "Blue", 5: "Green", "Red": 0, "Green": 5, "Blue": 2}
// Color.Red → 0
// Color.Green → 5
// Color.Blue → 2
// Color[5] → Green
// Color.Blue > Color.Green → false

Y aquí hay un lodash mixin para crear una enumeración usando una cadena. Si bien esta versión es un poco más complicada, hace la numeración automáticamente por usted. Todos los métodos lodash utilizados en este ejemplo tienen un equivalente de JavaScript regular, por lo que puede cambiarlos fácilmente si lo desea.

function enum() {
    var key, val = -1, list = {};
    _.reduce(_.toArray(arguments), function(result, kvp) {    
        kvp = kvp.split("=");
        key = _.trim(kvp[0]);
        val = _.parseInt(kvp[1]) || ++val;            
        result[result[val] = key] = val;
        return result;
    }, list);
    return Object.freeze(list);
}    

// Add enum to lodash 
_.mixin({ "enum": enum });

var Color = _.enum(
    "Red",
    "Green",
    "Blue = 5",
    "Yellow",
    "Purple = 20",
    "Gray"
);

// Color.Red → 0
// Color.Green → 1
// Color.Blue → 5
// Color.Yellow → 6
// Color.Purple → 20
// Color.Gray → 21
// Color[5] → Blue

Acabo de publicar un paquete NPM gen_enum le permite crear una estructura de datos de Enum en Javascript rápidamente:

var genEnum = require('gen_enum');

var AppMode = genEnum('SIGN_UP, LOG_IN, FORGOT_PASSWORD');
var curMode = AppMode.LOG_IN;
console.log(curMode.isLogIn()); // output true 
console.log(curMode.isSignUp()); // output false 
console.log(curMode.isForgotPassword()); // output false 

Una cosa buena de esta pequeña herramienta es en el entorno moderno (incluidos los navegadores nodejs e IE 9+), el objeto Enum devuelto es inmutable.

Para obtener más información, consulte https://github.com/greenlaw110/enumjs

Actualizaciones

Obtuve el paquete obsoleto gen_enumy fusiono la función en el paquete constjs , que proporciona más funciones, incluidos objetos inmutables, deserialización de cadenas JSON, constantes de cadenas y generación de mapas de bits, etc. Consulte https://www.npmjs.com/package/constjs para obtener más información

Para actualizar desde gen_enumque constjsacaba de cambiar la declaración

var genEnum = require('gen_enum');

a

var genEnum = require('constjs').enum;

La solución más simple:

Crear

var Status = Object.freeze({
    "Connecting":0,
    "Ready":1,
    "Loading":2,
    "Processing": 3
});

Obtenga valor

console.log(Status.Ready) // 1

Obtener la clave

console.log(Object.keys(Status)[Status.Ready]) // Ready

He creado una clase Enum que puede obtener valores Y nombres en O (1). También puede generar una matriz de objetos que contiene todos los nombres y valores.

function Enum(obj) {
    // Names must be unique, Values do not.
    // Putting same values for different Names is risky for this implementation

    this._reserved = {
        _namesObj: {},
        _objArr: [],
        _namesArr: [],
        _valuesArr: [],
        _selectOptionsHTML: ""
    };

    for (k in obj) {
        if (obj.hasOwnProperty(k)) {
            this[k] = obj[k];
            this._reserved._namesObj[obj[k]] = k;
        }
    }
}
(function () {
    this.GetName = function (val) {
        if (typeof this._reserved._namesObj[val] === "undefined")
            return null;
        return this._reserved._namesObj[val];
    };

    this.GetValue = function (name) {
        if (typeof this[name] === "undefined")
            return null;
        return this[name];
    };

    this.GetObjArr = function () {
        if (this._reserved._objArr.length == 0) {
            var arr = [];
            for (k in this) {
                if (this.hasOwnProperty(k))
                    if (k != "_reserved")
                        arr.push({
                            Name: k,
                            Value: this[k]
                        });
            }
            this._reserved._objArr = arr;
        }
        return this._reserved._objArr;
    };

    this.GetNamesArr = function () {
        if (this._reserved._namesArr.length == 0) {
            var arr = [];
            for (k in this) {
                if (this.hasOwnProperty(k))
                    if (k != "_reserved")
                        arr.push(k);
            }
            this._reserved._namesArr = arr;
        }
        return this._reserved._namesArr;
    };

    this.GetValuesArr = function () {
        if (this._reserved._valuesArr.length == 0) {
            var arr = [];
            for (k in this) {
                if (this.hasOwnProperty(k))
                    if (k != "_reserved")
                        arr.push(this[k]);
            }
            this._reserved._valuesArr = arr;
        }
        return this._reserved._valuesArr;
    };

    this.GetSelectOptionsHTML = function () {
        if (this._reserved._selectOptionsHTML.length == 0) {
            var html = "";
            for (k in this) {
                if (this.hasOwnProperty(k))
                    if (k != "_reserved")
                        html += "<option value='" + this[k] + "'>" + k + "</option>";
            }
            this._reserved._selectOptionsHTML = html;
        }
        return this._reserved._selectOptionsHTML;
    };
}).call(Enum.prototype);

Puedes iniciarlo así:

var enum1 = new Enum({
    item1: 0,
    item2: 1,
    item3: 2
});

Para obtener un valor (como Enums en C #):

var val2 = enum1.item2;

Para buscar un nombre para un valor (puede ser ambiguo al poner el mismo valor para diferentes nombres):

var name1 = enum1.GetName(0);  // "item1"

Para obtener una matriz con cada nombre y valor en un objeto:

var arr = enum1.GetObjArr();

Generará:

[{ Name: "item1", Value: 0}, { ... }, ... ]

También puede obtener las opciones de selección html fácilmente:

var html = enum1.GetSelectOptionsHTML();

Que tiene:

"<option value='0'>item1</option>..."

A pesar de que solo los métodos estáticos (y no las propiedades estáticas) son compatibles con ES2015 (consulte aquí también, §15.2.2.2), curiosamente puede usar lo siguiente con Babel con el valor es2015predeterminado:

class CellState {
    v: string;
    constructor(v: string) {
        this.v = v;
        Object.freeze(this);
    }
    static EMPTY       = new CellState('e');
    static OCCUPIED    = new CellState('o');
    static HIGHLIGHTED = new CellState('h');
    static values      = function(): Array<CellState> {
        const rv = [];
        rv.push(CellState.EMPTY);
        rv.push(CellState.OCCUPIED);
        rv.push(CellState.HIGHLIGHTED);
        return rv;
    }
}
Object.freeze(CellState);

Descubrí que esto funciona como se esperaba incluso en todos los módulos (por ejemplo, importar la CellStateenumeración de otro módulo) y también cuando importo un módulo usando Webpack.

La ventaja que tiene este método sobre la mayoría de las otras respuestas es que puede usarlo junto con un verificador de tipo estático (por ejemplo, Flow ) y puede afirmar, en el momento del desarrollo usando la verificación de tipo estático, que sus variables, parámetros, etc. son específicosCellState " enum "en lugar de algún otro enum (que sería imposible de distinguir si utilizara objetos o símbolos genéricos).

actualizar

El código anterior tiene una deficiencia, ya que le permite a uno crear objetos de tipo adicionales CellState(a pesar de que uno no puede asignarlos a los campos estáticos CellStateya que está congelado). Aún así, el siguiente código más refinado ofrece las siguientes ventajas:

1. no más objetos de tipo CellState se pueden crear
2. tiene garantizado que no hay dos instancias enum asignadas al mismo código
3. método de utilidad para recuperar la enumeración de una representación de cadena

4. la valuesfunción que devuelve todas las instancias de la enumeración no tiene que crear el valor de retorno de la manera anterior, manual (y propensa a errores).

   'use strict';
   
   class Status {
   
   constructor(code, displayName = code) {
       if (Status.INSTANCES.has(code))
           throw new Error(`duplicate code value: [${code}]`);
       if (!Status.canCreateMoreInstances)
           throw new Error(`attempt to call constructor(${code}`+
          `, ${displayName}) after all static instances have been created`);
       this.code        = code;
       this.displayName = displayName;
       Object.freeze(this);
       Status.INSTANCES.set(this.code, this);
   }
   
   toString() {
       return `[code: ${this.code}, displayName: ${this.displayName}]`;
   }
   static INSTANCES   = new Map();
   static canCreateMoreInstances      = true;
   
   // the values:
   static ARCHIVED    = new Status('Archived');
   static OBSERVED    = new Status('Observed');
   static SCHEDULED   = new Status('Scheduled');
   static UNOBSERVED  = new Status('Unobserved');
   static UNTRIGGERED = new Status('Untriggered');
   
   static values      = function() {
       return Array.from(Status.INSTANCES.values());
   }
   
   static fromCode(code) {
       if (!Status.INSTANCES.has(code))
           throw new Error(`unknown code: ${code}`);
       else
           return Status.INSTANCES.get(code);
   }
   }
   
   Status.canCreateMoreInstances = false;
   Object.freeze(Status);
   exports.Status = Status;

es7 way, (iterador, congelación), uso:

const ThreeWiseMen = new Enum('Melchior', 'Caspar', 'Balthazar')

for (let name of ThreeWiseMen)
    console.log(name)


// with a given key
let key = ThreeWiseMen.Melchior

console.log(key in ThreeWiseMen) // true (string conversion, also true: 'Melchior' in ThreeWiseMen)

for (let entry from key.enum)
     console.log(entry)


// prevent alteration (throws TypeError in strict mode)
ThreeWiseMen.Me = 'Me too!'
ThreeWiseMen.Melchior.name = 'Foo'

código:

class EnumKey {

    constructor(props) { Object.freeze(Object.assign(this, props)) }

    toString() { return this.name }

}

export class Enum {

    constructor(...keys) {

        for (let [index, key] of keys.entries()) {

            Object.defineProperty(this, key, {

                value: new EnumKey({ name:key, index, enum:this }),
                enumerable: true,

            })

        }

        Object.freeze(this)

    }

    *[Symbol.iterator]() {

        for (let key of Object.keys(this))
            yield this[key]

    }

    toString() { return [...this].join(', ') }

}

Así es como mecanografía se traduce enumen Javascript:

var makeEnum = function(obj) {
    obj[ obj['Active'] = 1 ] = 'Active';
    obj[ obj['Closed'] = 2 ] = 'Closed';
    obj[ obj['Deleted'] = 3 ] = 'Deleted';
}