这是我使用的解决方案。

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

一些缺点：

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

这是我知道的一个旧版本，但它通过TypeScript接口实现的方式是：

var MyEnum;
(function (MyEnum) {
    MyEnum[MyEnum["Foo"] = 0] = "Foo";
    MyEnum[MyEnum["FooBar"] = 2] = "FooBar";
    MyEnum[MyEnum["Bar"] = 1] = "Bar";
})(MyEnum|| (MyEnum= {}));

这使您能够查找返回1的MyEnum.Bar和返回“Bar”的MyEnum[1]，无论声明的顺序如何。

您可以使用一个简单的函数来反转键和值，当它将数字整数字符串转换为数字时，它也可以处理数组。代码小、简单，可用于此用例和其他用例。

var objInvert=函数（obj）{var反转=｛｝for（对象中的变量i）{如果（i.match（/^\d+$/））i=parseInt（i，10）反转[obj[i]]=i}返回反转}var musicStyles=对象冻结（objInvert（['ROCK'，'SURF'，'METAL'，“BOSSA-NOVA”、“op”、“die”]））console.log（音乐样式）

这个答案是针对特定情况的另一种方法。我需要一组基于属性子值的位掩码常量（属性值是数组或值列表的情况）。它包含几个重叠枚举的等价物。

我创建了一个类来存储和生成位掩码值。然后，我可以用这种方式使用伪常量位掩码值来测试，例如，如果RGB值中存在绿色：

if (value & Ez.G) {...}

在我的代码中，我只创建了这个类的一个实例。在不实例化类的至少一个实例的情况下，似乎没有一种干净的方法可以做到这一点。以下是类声明和位掩码值生成代码：

class Ez {
constructor() {
    let rgba = ["R", "G", "B", "A"];
    let rgbm = rgba.slice();
    rgbm.push("M");              // for feColorMatrix values attribute
    this.createValues(rgba);
    this.createValues(["H", "S", "L"]);
    this.createValues([rgba, rgbm]);
    this.createValues([attX, attY, attW, attH]);
}
createValues(a) {                // a for array
    let i, j;
    if (isA(a[0])) {             // max 2 dimensions
        let k = 1;
        for (i of a[0]) {
            for (j of a[1]) {
                this[i + j] = k;
                k *= 2;
            }
        }
    }
    else {                       // 1D array is simple loop
        for (i = 0, j = 1; i < a.length; i++, j *= 2)
            this[a[i]] = j;
   }
}

2D数组用于SVG feColorMatrix值属性，该属性是RGBA和RGBAM的4x5矩阵，其中M是乘数。得到的Ez财产为Ez.RR、Ez.RG等。

您可以使用Object.protype.hasOwnProperty（）

变量findInEnum，颜色枚举={红色：0，绿色：1，蓝色：2};//稍后findInEnum=函数（enumKey）{if（colorEnum.hasOwnProperty（enumKey））{return enumKey+“值：”+colorEnum[nenumKey]}}警报（findInEnum（“蓝色”））

底线：你不能。

你可以伪造它，但你不会得到类型安全。通常，这是通过创建映射到整数值的字符串值的简单字典来完成的。例如：

var DaysEnum = {"monday":1, "tuesday":2, "wednesday":3, ...}

Document.Write("Enumerant: " + DaysEnum.tuesday);

这种方法有什么问题？您可能会意外地重新定义枚举，或者意外地具有重复的枚举值。例如：

DaysEnum.monday = 4; // whoops, monday is now thursday, too

编辑

Artur Czajka的Object.freeze呢？这难道不会阻止你将星期一设置为星期四吗油炸四方饼

当然，Object.freeze可以完全解决我投诉的问题。我想提醒大家，当我写上述内容时，Object.freeze并不存在。

现在现在它打开了一些非常有趣的可能性。

编辑2这里有一个非常好的用于创建枚举的库。

http://www.2ality.com/2011/10/enums.html

虽然它可能不适合枚举的每一种有效使用，但它需要很长的路。