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

您不需要确保不以这种方式将重复的数字分配给不同的枚举值。一个新对象被实例化并分配给所有枚举值。

我也在寻找这个问题的答案，并找到了这一页的答案，我认为答案与这里的大多数答案不同：https://www.sohamkamani.com/javascript/enums/

我将把文章的答案部分复制到这里，以防将来链接无效或其他情况：

带符号的枚举：符号让我们定义保证不会冲突的值彼此之间。例如：

const Summer1 = Symbol("summer")
const Summer2 = Symbol("summer")

// Even though they have the same apparent value
// Summer1 and Summer2 don't equate
console.log(Summer1 === Summer2)
// false

console.log(Summer1)

我们可以使用符号定义枚举，以确保它们不是复制：

const Summer = Symbol("summer")
const Autumn = Symbol("autumn")
const Winter = Symbol("winter")
const Spring = Symbol("spring")

let season = Spring

switch (season) {
    case Summer:
    console.log('the season is summer')
    break;
    case Winter:
    console.log('the season is winter')
    break;
    case Spring:
    console.log('the season is spring')
    break;
    case Autumn:
    console.log('the season is autumn')
    break;
    default:
    console.log('season not defined')
}

使用Symbol可以确保我们分配枚举值的唯一方法是使用我们最初定义的常量。

具有类的枚举：

为了使代码更加语义正确，我们可以创建一个类保存一组枚举。例如，我们的季节应该有一种方法来识别它们都属于类似的分类。让我们看看如何使用类和对象创建不同的枚举组：

// Season enums can be grouped as static members of a class
class Season {
  // Create new instances of the same class as static attributes
  static Summer = new Season("summer")
  static Autumn = new Season("autumn")
  static Winter = new Season("winter")
  static Spring = new Season("spring")

  constructor(name) {
    this.name = name
  }
}

// Now we can access enums using namespaced assignments
// this makes it semantically clear that "Summer" is a "Season"
let season = Season.Summer

// We can verify whether a particular variable is a Season enum
console.log(season instanceof Season)
// true
console.log(Symbol('something') instanceof Season)
//false

// We can explicitly check the type based on each enums class
console.log(season.constructor.name)
// 'Season'

个人注意：我本应该使用此构造函数：（注意：将this.name设置为字符串而不是对象，会丢失以下一些验证。可以选择删除：.description。我还想找到一种方法，不必键入Seasons.summer.name，而只需：Seasons.summer即可使其返回字符串）

  constructor(name) {
    this.name = Symbol(name).description
  }

列出所有可能的枚举值：

如果我们使用上述基于类的方法Season类的键，以获取同一类下的所有枚举值组：

Object.keys(Season).forEach(season => console.log("season:", season))
// season: Summer
// season: Autumn
// season: Winter
// season: Spring

何时在Javascript中使用枚举？

通常，如果有一定数量的固定任何一个变量的值_例如，Node.js的加密标准库有一个受支持的算法列表，可以将其视为枚举组。正确使用Javascript中的enums将产生更好的代码更稳定、更容易阅读和更少出错。

我修改了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);
    }
  }

测试：

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

创建对象文字：

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

在大多数现代浏览器中，有一种符号基元数据类型，可用于创建枚举。它将确保枚举的类型安全，因为JavaScript保证每个符号值都是唯一的，即symbol（）！=符号（）。例如：

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

为了简化调试，可以向枚举值添加描述：

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

Plunker演示

在GitHub上，您可以找到一个包装器，它简化了初始化枚举所需的代码：

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

export const ButtonType = Object.freeze({ 
   DEFAULT: 'default', 
   BIG: 'big', 
   SMALL: 'small'
})

来源：https://medium.com/@idanlevi2/enum-in-javascript-5f2ff500f149