Enumeraciones en Javascript con ES6

Estoy reconstruyendo un antiguo proyecto Java en Javascript y me di cuenta de que no hay una buena manera de hacer enumeraciones en JS.

Lo mejor que se me ocurre es:

const Colors = {
    RED: Symbol("red"),
    BLUE: Symbol("blue"),
    GREEN: Symbol("green")
};
Object.freeze(Colors);

los const mantiene Colors ser reasignado, y congelarlo evita la mutación de claves y valores. Estoy usando símbolos para que Colors.RED no es igual a 0o cualquier otra cosa además de sí mismo.

¿Hay algún problema con esta formulación? ¿Hay una mejor manera?

(Sé que esta pregunta se repite un poco, pero todas las preguntas y respuestas anteriores son bastante antiguas y ES6 nos brinda algunas capacidades nuevas).

EDITAR:

Otra solución, que se ocupa del problema de serialización, pero creo que todavía tiene problemas de reino:

const enumValue = (name) => Object.freeze({toString: () => name});

const Colors = Object.freeze({
    RED: enumValue("Colors.RED"),
    BLUE: enumValue("Colors.BLUE"),
    GREEN: enumValue("Colors.GREEN")
});

Al utilizar referencias a objetos como valores, obtiene la misma prevención de colisiones que los símbolos.

¿Hay algún problema con esta formulación?

no veo ninguno

¿Hay una mejor manera?

Colapsaría las dos declaraciones en una sola:

const Colors = Object.freeze({
    RED:   Symbol("red"),
    BLUE:  Symbol("blue"),
    GREEN: Symbol("green")
});

Si no te gusta el repetitivo, dale me gusta al repetido Symbol llamadas, por supuesto también puede escribir una función de ayuda makeEnum que crea lo mismo a partir de una lista de nombres.

mientras usa Symbol como el valor de enumeración funciona bien para casos de uso simples, puede ser útil dar propiedades a las enumeraciones. Esto se puede hacer usando un Object como el valor de enumeración que contiene las propiedades.

Por ejemplo, podemos dar a cada uno de los Colors un nombre y un valor hexadecimal:

/**
 * Enum for common colors.
 * @readonly
 * @enum {{name: string, hex: string}}
 */
const Colors = Object.freeze({
  RED:   { name: "red", hex: "#f00" },
  BLUE:  { name: "blue", hex: "#00f" },
  GREEN: { name: "green", hex: "#0f0" }
});

Incluir propiedades en la enumeración evita tener que escribir switch declaraciones (y posiblemente olvidar nuevos casos a las declaraciones de cambio cuando se extiende una enumeración). El ejemplo también muestra las propiedades de enumeración y los tipos documentados con el Anotación de enumeración JSDoc.

La igualdad funciona como se esperaba con Colors.RED === Colors.RED siendo truey Colors.RED === Colors.BLUE siendo false.

Este es mi enfoque personal.

class ColorType {
    static get RED () {
        return "red";
    }

    static get GREEN () {
        return "green";
    }

    static get BLUE () {
        return "blue";
    }
}

// Use case.
const color = Color.create(ColorType.RED);

Como se mencionó anteriormente, también puede escribir un makeEnum() función auxiliar:

function makeEnum(arr){
    let obj = {};
    for (let val of arr){
        obj[val] = Symbol(val);
    }
    return Object.freeze(obj);
}

Úsalo así:

const Colors = makeEnum(["red","green","blue"]);
let startColor = Colors.red; 
console.log(startColor); // Symbol(red)

if(startColor == Colors.red){
    console.log("Do red things");
}else{
    console.log("Do non-red things");
}

si no necesitas puro ES6 y puede usar Typescript, tiene un buen enum:

https://www.typescriptlang.org/docs/handbook/enums.html

Actualización 11.05.2020:

Modificado para incluir campos y métodos estáticos para replicar más de cerca el comportamiento de enumeración “verdadero”.

Si planea actualizar, le recomendaría intentar usar lo que llamo una “Clase Enum” (salvo cualquier limitación del navegador o entorno de tiempo de ejecución que no pueda aceptar). es básicamente un muy simple y una clase limpia que usa campos privados y accesos limitados para simular el comportamiento de una enumeración. Esto es algo que a veces hago en C# cuando quiero incorporar más funciones en una enumeración.

Me doy cuenta de que los campos de clase privada aún son experimentales en este momento, pero parece funcionar para crear una clase con campos/propiedades inmutables. El soporte del navegador también es decente. Los únicos navegadores “principales” que no lo admiten son Firefox (que estoy seguro de que lo harán pronto) e IE (a quién le importa).

DESCARGO DE RESPONSABILIDAD:
No soy un desarrollador. Acabo de armar esto para resolver las limitaciones de las enumeraciones inexistentes en JS cuando estaba trabajando en un proyecto personal.

Clase de muestra

class Colors {
    // Private Fields
    static #_RED = 0;
    static #_GREEN = 1;
    static #_BLUE = 2;

    // Accessors for "get" functions only (no "set" functions)
    static get RED() { return this.#_RED; }
    static get GREEN() { return this.#_GREEN; }
    static get BLUE() { return this.#_BLUE; }
}

Ahora debería poder llamar a sus enumeraciones directamente.

Colors.RED; // 0
Colors.GREEN; // 1
Colors.BLUE; // 2

La combinación de usar campos privados y accesos limitados significa que los valores de enumeración existentes están bien protegidos (ahora son esencialmente constantes).

Colors.RED = 10 // Colors.RED is still 0
Colors._RED = 10 // Colors.RED is still 0
Colors.#_RED = 10 // Colors.RED is still 0

Controlar cómo lo hace TypeScript. Básicamente hacen lo siguiente:

const MAP = {};

MAP[MAP[1] = 'A'] = 1;
MAP[MAP[2] = 'B'] = 2;

MAP['A'] // 1
MAP[1] // A

Usa símbolos, congela objetos, lo que quieras.