这是我使用的解决方案。

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类具有一些关联缓存

一些缺点：

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

我不久前使用了__defineGetter__和__defineSetter__或defineProperty的组合，具体取决于JS版本。

下面是我制作的枚举生成函数：https://gist.github.com/gfarrell/6716853

你可以这样使用：

var Colours = Enum('RED', 'GREEN', 'BLUE');

它将创建一个不可变的字符串：int字典（一个枚举）。

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

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

在ES7中，您可以依靠静态属性执行优雅的ENUM：

class ColorEnum  {
    static RED = 0 ;
    static GREEN = 1;
    static BLUE = 2;
}

然后

if (currentColor === ColorEnum.GREEN ) {/*-- coding --*/}

（使用类而不是文本对象）的优点是有一个父类Enum，然后所有Enum都将扩展该类。

 class ColorEnum  extends Enum {/*....*/}

阅读了所有的答案，没有找到任何非冗长和干燥的解决方案。我使用这一行：

const modes = ['DRAW', 'SCALE', 'DRAG'].reduce((o, v) => ({ ...o, [v]: v }), {});

它生成具有人类可读值的对象：

{
  DRAW: 'DRAW',
  SCALE: 'SCALE',
  DRAG: 'DRAG'
}

var DaysEnum = Object.freeze ({ monday: {}, tuesday: {}, ... });

您不需要指定id，只需使用空对象来比较枚举即可。

if (incommingEnum === DaysEnum.monday) //incommingEnum is monday

EDIT：如果要序列化对象（例如JSON），将再次输入id。

（摘自加布里埃尔·利亚马斯评论）（根据Stijn de Witt的评论进行编辑）