你可以试试这个：

   var Enum = Object.freeze({
            Role: Object.freeze({ Administrator: 1, Manager: 2, Supervisor: 3 }),
            Color:Object.freeze({RED : 0, GREEN : 1, BLUE : 2 })
            });

    alert(Enum.Role.Supervisor);
    alert(Enum.Color.GREEN);
    var currentColor=0;
    if(currentColor == Enum.Color.RED) {
       alert('Its Red');
    }

我也在寻找这个问题的答案，并找到了这一页的答案，我认为答案与这里的大多数答案不同：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将产生更好的代码更稳定、更容易阅读和更少出错。

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

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

使用Javascript代理

TLDR：将这个类添加到实用程序方法中，并在整个代码中使用它，它模拟了传统编程语言中的Enum行为，当您尝试访问不存在的枚举器或添加/更新枚举器时，实际上会抛出错误。无需依赖Object.creeze（）。

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);
  }
}

然后通过实例化类创建枚举：

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

完整解释：

从传统语言中获得的Enum的一个非常有益的特性是，如果您试图访问不存在的枚举器，它们就会爆炸（引发编译时错误）。

除了冻结模拟枚举结构以防止意外/恶意添加附加值之外，其他答案都没有解决枚举的固有特性。

正如您可能知道的，在JavaScript中访问不存在的成员只会返回undefined，不会破坏代码。由于枚举数是预定义的常量（即一周中的几天），因此不应出现枚举数未定义的情况。

不要误解我的意思，JavaScript在访问未定义的财产时返回未定义的行为实际上是语言的一个非常强大的功能，但当您试图模拟传统Enum结构时，这并不是您想要的功能。

这是代理对象发光的地方。随着ES6（ES2015）的引入，代理被标准化为语言。以下是MDN的描述：

Proxy对象用于定义基本操作（例如属性查找、赋值、枚举、函数）的自定义行为调用等）。

与web服务器代理类似，JavaScript代理能够拦截对象上的操作（使用“陷阱”，如果您愿意，可以将其称为钩子），并允许您在操作完成之前执行各种检查、操作和/或操作（或者在某些情况下完全停止操作，这正是我们在尝试引用不存在的枚举器时想要做的）。

下面是一个精心设计的示例，它使用Proxy对象来模拟Enum。本例中的枚举器是标准HTTP方法（即“GET”、“POST”等）：

//用于创建枚举的类（13行）//请随意将其添加到中的实用程序库//你的代码库和利润！注：因为代理是ES6//功能，某些浏览器/客户端可能不支持//您可能需要使用babel这样的服务进行transfile类枚举{//Enum类实例化JavaScript代理对象。//实例化“代理”对象需要两个参数，//“target”对象和“handler”。我们首先定义处理程序，//然后使用处理程序实例化代理。//代理处理程序只是一个对象，它的财产//是定义代理行为的函数//当对其执行操作时。//对于枚举，我们需要定义允许我们检查枚举器的行为//正在访问以及正在设置的枚举器。这可以通过以下方式实现//定义“get”和“set”陷阱。构造函数（enumObj）{常量处理程序={get（目标，名称）{if（目标类型[名称]！='undefined'）{返回目标[名称]}抛出新错误（`没有这样的枚举器：$｛name｝`）},设置（）{throw new Error（“定义枚举实例后无法在其上添加/更新财产”）}}//冻结目标对象以防止修改返回新代理（enumObj，处理程序）}}//现在我们有了创建Enum的通用方法，让我们创建第一个Enum！const httpMethods=新枚举({DELETE：“删除”，GET：“GET”，OPTIONS：“选项”，PATCH：“补丁”，POST:“POST”，PUT：“PUT”})//卫生检查console.log（httpMethods.DELETE）//日志“DELETE”尝试{httpMethods.delete=“删除”}捕获（e）{console.log（“错误：”，e.message）}//throws“定义Enum实例后，无法在其上添加/更新财产”尝试{console.log（httpMethods.delete）}捕获（e）{console.log（“错误：”，e.message）}//throws“没有这样的枚举器：delete”

ASIDE：代理到底是什么？

我记得当我第一次开始在任何地方看到代理这个词的时候，我很长一段时间都觉得它毫无意义。如果你现在是这样的话，我认为概括代理的一个简单方法是将它们视为软件、机构，甚至是充当两个服务器、公司或人员之间的中间人或中间人的人。

这不是一个很好的答案，但我个人认为这很好

话虽如此，因为值是什么并不重要（您使用了0、1、2），所以我会使用一个有意义的字符串，以防您想要输出当前值。

截至2014年10月的撰写，这里有一个当代的解决方案。我将解决方案作为节点模块编写，并使用Mocha和Chai以及undercoreJS进行了测试。您可以很容易地忽略这些，如果愿意，只需使用Enum代码。

看到了很多带有过于复杂的库等的帖子。在Javascript中获得枚举支持的解决方案非常简单，真的不需要。代码如下：

文件：enums.js

_ = require('underscore');

var _Enum = function () {

   var keys = _.map(arguments, function (value) {
      return value;
   });
   var self = {
      keys: keys
   };
   for (var i = 0; i < arguments.length; i++) {
      self[keys[i]] = i;
   }
   return self;
};

var fileFormatEnum = Object.freeze(_Enum('CSV', 'TSV'));
var encodingEnum = Object.freeze(_Enum('UTF8', 'SHIFT_JIS'));

exports.fileFormatEnum = fileFormatEnum;
exports.encodingEnum = encodingEnum;

还有一个测试来说明它给你带来了什么：

文件：enumsSpec.js

var chai = require("chai"),
    assert = chai.assert,
    expect = chai.expect,
    should = chai.should(),
    enums = require('./enums'),
    _ = require('underscore');


describe('enums', function () {

    describe('fileFormatEnum', function () {
        it('should return expected fileFormat enum declarations', function () {
            var fileFormatEnum = enums.fileFormatEnum;
            should.exist(fileFormatEnum);
            assert('{"keys":["CSV","TSV"],"CSV":0,"TSV":1}' === JSON.stringify(fileFormatEnum), 'Unexpected format');
            assert('["CSV","TSV"]' === JSON.stringify(fileFormatEnum.keys), 'Unexpected keys format');
        });
    });

    describe('encodingEnum', function () {
        it('should return expected encoding enum declarations', function () {
            var encodingEnum = enums.encodingEnum;
            should.exist(encodingEnum);
            assert('{"keys":["UTF8","SHIFT_JIS"],"UTF8":0,"SHIFT_JIS":1}' === JSON.stringify(encodingEnum), 'Unexpected format');
            assert('["UTF8","SHIFT_JIS"]' === JSON.stringify(encodingEnum.keys), 'Unexpected keys format');
        });
    });

});

正如您所看到的，您获得了一个Enum工厂，只需调用Enum.keys即可获得所有键，并且可以将键本身与整数常量匹配。您可以使用不同的值重用工厂，并使用Node的模块化方法导出生成的Enum。

同样，如果您只是一个普通用户，或者在浏览器等中，只需使用代码的工厂部分，如果您不想在代码中使用下划线库，也可能会删除它。