我对任何答案都不满意，所以我制作了《又一个枚举》（YEA！）。

此实施：

使用最新的JS只需要这一类的声明即可轻松创建enum具有按名称（colors.RED）、字符串（colors[“RED”]）和索引（colors[0]）进行的映射，但只需将字符串作为数组传递将等价于String（）和valueOf（）函数绑定到每个enum对象（如果不希望这样做，可以简单地删除它-不过JS的开销很小）具有可选的全局命名/存储（按名称字符串）创建后冻结枚举对象，使其无法修改

特别感谢Andre‘Fi的回答给了我们一些启发。

代码：

class Enums {
  static create({ name = undefined, items = [] }) {
    let newEnum = {};
    newEnum.length = items.length;
    newEnum.items = items;
    for (let itemIndex in items) {
      //Map by name.
      newEnum[items[itemIndex]] = parseInt(itemIndex, 10);
      //Map by index.
      newEnum[parseInt(itemIndex, 10)] = items[itemIndex];
    }
    newEnum.toString = Enums.enumToString.bind(newEnum);
    newEnum.valueOf = newEnum.toString;
    //Optional naming and global registration.
    if (name != undefined) {
      newEnum.name = name;
      Enums[name] = newEnum;
    }
    //Prevent modification of the enum object.
    Object.freeze(newEnum);
    return newEnum;
  }
  static enumToString() {
    return "Enum " +
      (this.name != undefined ? this.name + " " : "") +
      "[" + this.items.toString() + "]";
  }
}

用法：

let colors = Enums.create({
  name: "COLORS",
  items: [ "RED", "GREEN", "BLUE", "PORPLE" ]
});

//Global access, if named.
Enums.COLORS;

colors.items; //Array(4) [ "RED", "GREEN", "BLUE", "PORPLE" ]
colors.length; //4

colors.RED; //0
colors.GREEN; //1
colors.BLUE; //2
colors.PORPLE; //3
colors[0]; //"RED"
colors[1]; //"GREEN"
colors[2]; //"BLUE"
colors[3]; //"PORPLE"

colors.toString(); //"Enum COLORS [RED,GREEN,BLUE,PORPLE]"

//Enum frozen, makes it a real enum.
colors.RED = 9001;
colors.RED; //0

这可能很有用：

const [CATS, DOGS, BIRDS] = ENUM();

实施简单高效：

function * ENUM(count=1) { while(true) yield count++ }

生成器可以产生所需的整数的精确序列，而不知道有多少常数。它还可以支持一个可选参数，该参数指定从哪个（可能是负数）数字开始（默认为1）。

这是我使用的解决方案。

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

您可以这样定义枚举：

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

以下是访问枚举的方式：

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

我通常使用最后两种方法从消息对象映射enum。

这种方法的一些优点：

易于声明枚举易于访问您的枚举枚举可以是复杂类型如果经常使用getByValue，Enum类具有一些关联缓存

一些缺点：

由于我保留了对枚举的引用，内存管理有些混乱仍然没有类型安全性

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

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

我刚刚发布了一个NPM包gen_enum，它允许您在Javascript中快速创建enum数据结构：

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 

这个小工具的一个优点是在现代环境中（包括nodejs和IE9+浏览器），返回的Enum对象是不可变的。

有关更多信息，请结账https://github.com/greenlaw110/enumjs

更新

我淘汰了gen_enum包，并将该函数合并到constjs包中，该包提供了更多功能，包括不可变对象、JSON字符串反序列化、字符串常量和位图生成等。签出https://www.npmjs.com/package/constjs了解更多信息

要从gen_enum升级到constjs，只需更改语句

var genEnum = require('gen_enum');

to

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

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

使用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)

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