使用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：代理到底是什么？

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

更新

我认为我下面的答案不再是用JavaScript编写枚举的最佳方法。有关更多详细信息，请参阅我的博客文章：JavaScript中的枚举。

已经可以提醒名称：

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

或者，您可以创建值对象，这样您就可以吃蛋糕了：

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

在JavaScript中，因为它是一种动态语言，所以以后甚至可以向集合中添加枚举值：

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

记住，枚举的字段（本例中的值、名称和代码）不需要用于身份检查，只是为了方便。此外，大小属性本身的名称不需要硬编码，也可以动态设置。因此，假设您只知道新枚举值的名称，您仍然可以毫无问题地添加它：

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

当然，这意味着无法再进行某些假设（例如，该值表示大小的正确顺序）。

记住，在JavaScript中，对象就像一个映射或哈希表。一组名称值对。你可以在事先不了解它们的情况下循环浏览它们或以其他方式操纵它们。

实例

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.        
  }
} 

顺便说一句，如果你对名称空间感兴趣，你可能想看看我为JavaScript提供的简单但强大的名称空间和依赖关系管理的解决方案：Packages JS

我编写了enumeranjs一个非常小的库来解决这个问题，它确保了类型安全，允许枚举常量从原型继承，保证枚举常量和枚举类型是不可变的+许多小特性。它允许重构大量代码，并在枚举定义中移动一些逻辑。下面是一个示例：

var CloseEventCodes = new Enumeration("closeEventCodes", {
  CLOSE_NORMAL:          { _id: 1000, info: "Connection closed normally" },
  CLOSE_GOING_AWAY:      { _id: 1001, info: "Connection closed going away" },
  CLOSE_PROTOCOL_ERROR:  { _id: 1002, info: "Connection closed due to protocol error"  },
  CLOSE_UNSUPPORTED:     { _id: 1003, info: "Connection closed due to unsupported operation" },
  CLOSE_NO_STATUS:       { _id: 1005, info: "Connection closed with no status" },
  CLOSE_ABNORMAL:        { _id: 1006, info: "Connection closed abnormally" },
  CLOSE_TOO_LARGE:       { _id: 1009, info: "Connection closed due to too large packet" }
},{ talk: function(){
    console.log(this.info); 
  }
});


CloseEventCodes.CLOSE_TOO_LARGE.talk(); //prints "Connection closed due to too large packet"
CloseEventCodes.CLOSE_TOO_LARGE instanceof CloseEventCodes //evaluates to true

枚举基本上是一个工厂。

此处提供完整记录的指南。希望这有帮助。

IE8不支持冻结（）方法。资料来源：http://kangax.github.io/compat-table/es5/，单击顶部的“显示过时的浏览器？”，然后检查IE8并冻结行列交叉点。

在我目前的游戏项目中，我使用了以下内容，因为很少有客户仍然使用IE8：

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

我们还可以做到：

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

或者甚至是这样：

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

最后一个，对于字符串来说似乎是最有效的，如果您让服务器和客户端交换这些数据，它会减少您的总带宽。当然，现在您有责任确保数据中没有冲突（RE、EX等必须唯一，1、2等也必须唯一）。请注意，为了向后兼容，您需要永远保持这些。

分配：

var wildType = CONST_WILD_TYPES.REGULAR;

对比：

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

外星人的解决方案是让事情尽可能简单：

使用enum关键字（在javascript中保留）如果enum关键字只是保留的，但未在javascript中实现，请定义以下内容constenumerate=spec=>spec.split（/\s*，\s*/）.reduce（（e，n）=>对象.assign（e，{[n]:n}），{}）

现在，您可以轻松使用它

const kwords = enumerate("begin,end, procedure,if")
console.log(kwords, kwords.if, kwords.if == "if", kwords.undef)

我认为没有理由使枚举值显式变量。无论如何，脚本都是纯文本的，如果代码的一部分是字符串或有效代码，则没有任何区别。真正重要的是，无论何时使用或定义引号，都不需要处理成吨的引号。

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

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