我修改了Andre“Fi”的解决方案：

  function Enum() {
    var that = this;
    for (var i in arguments) {
        that[arguments[i]] = i;
    }
    this.name = function(value) {
        for (var key in that) {
            if (that[key] == value) {
                return key;
            }
        }
    };
    this.exist = function(value) {
        return (typeof that.name(value) !== "undefined");
    };
    if (Object.freeze) {
        Object.freeze(that);
    }
  }

测试：

var Color = new Enum('RED', 'GREEN', 'BLUE');
undefined
Color.name(Color.REDs)
undefined
Color.name(Color.RED)
"RED"
Color.exist(Color.REDs)
false
Color.exist(Color.RED)
true

从1.8.5开始，可以密封和冻结物体，因此定义如下：

const DaysEnum = Object.freeze({"monday":1, "tuesday":2, "wednesday":3, ...})

or

const DaysEnum = {"monday":1, "tuesday":2, "wednesday":3, ...}
Object.freeze(DaysEnum)

瞧！JS枚举。

然而，这并不能阻止您为变量赋值，这通常是enums的主要目标：

let day = DaysEnum.tuesday
day = 298832342 // goes through without any errors

确保更强的类型安全性（使用enums或其他）的一种方法是使用TypeScript或Flow等工具。

不需要引用，但我保留了它们以保持一致性。

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

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

尽管ES2015中只支持静态方法（而不支持静态财产）（请参见§15.2.2.2），但奇怪的是，您可以将以下内容用于Babel和ES2015预设：

class CellState {
    v: string;
    constructor(v: string) {
        this.v = v;
        Object.freeze(this);
    }
    static EMPTY       = new CellState('e');
    static OCCUPIED    = new CellState('o');
    static HIGHLIGHTED = new CellState('h');
    static values      = function(): Array<CellState> {
        const rv = [];
        rv.push(CellState.EMPTY);
        rv.push(CellState.OCCUPIED);
        rv.push(CellState.HIGHLIGHTED);
        return rv;
    }
}
Object.freeze(CellState);

我发现，即使在模块之间（例如，从另一个模块导入CellState枚举），以及在使用Webpack导入模块时，这也能正常工作。

与大多数其他答案相比，此方法的优势在于，您可以将其与静态类型检查器（例如Flow）一起使用，并且您可以在开发时使用静态类型检查断言您的变量、参数等是特定的CellState“enum”，而不是其他枚举（如果您使用了泛型对象或符号，则无法区分）。

使现代化

上面的代码有一个缺点，即它允许创建CellState类型的其他对象（尽管由于CellState被冻结，因此无法将它们分配给CellState的静态字段）。尽管如此，以下更精细的代码提供了以下优点：

不能再创建CellState类型的对象可以保证没有两个枚举实例分配了相同的代码从字符串表示中获取枚举的实用方法返回枚举的所有实例的values函数不必以上述手动（且容易出错）的方式创建返回值。“使用严格”；类状态{构造函数（code，displayName=code）{if（Status.INSTANCES.has（代码））抛出新错误（`重复代码值：[$｛code｝]`）；if（！Status.canCreateMoreInstances）throw new Error（`尝试调用构造函数（$｛code｝`+`，$｛displayName｝）在创建所有静态实例后`）；this.code=代码；this.displayName=显示名称；对象.冻结（this）；Status.INSTANCES.set（this.code，this）；}到字符串（）{return `[code:$｛this.code｝，displayName:$｛this.displayName｝]`；}静态INSTANCES=新映射（）；静态canCreateMoreInstances=true；//值：静态ARCHIVED=新状态（“存档”）；静态观察=新状态（“观察”）；静态调度=新状态（“调度”）；静态UNOBERVED=新状态（“未观察”）；static UNTRIGGERED=新状态（“未触发”）；静态值=函数（）{return Array.from（Status.INSTANCES.values（））；}静态fromCode（代码）{if（！Status.INSTANCES.has（代码））抛出新错误（“未知代码：$｛code｝”）；其他的return Status.INSTANCES.get（代码）；}}Status.canCreateMoreInstances=false；对象冻结（状态）；exports.Status=状态；

最简单的解决方案：

创造

var Status = Object.freeze({
    "Connecting":0,
    "Ready":1,
    "Loading":2,
    "Processing": 3
});

获取价值

console.log(Status.Ready) // 1

获取密钥

console.log(Object.keys(Status)[Status.Ready]) // Ready

我制作了一个Enum类，它可以在O（1）处获取值和名称。它还可以生成包含所有名称和值的对象数组。

function Enum(obj) {
    // Names must be unique, Values do not.
    // Putting same values for different Names is risky for this implementation

    this._reserved = {
        _namesObj: {},
        _objArr: [],
        _namesArr: [],
        _valuesArr: [],
        _selectOptionsHTML: ""
    };

    for (k in obj) {
        if (obj.hasOwnProperty(k)) {
            this[k] = obj[k];
            this._reserved._namesObj[obj[k]] = k;
        }
    }
}
(function () {
    this.GetName = function (val) {
        if (typeof this._reserved._namesObj[val] === "undefined")
            return null;
        return this._reserved._namesObj[val];
    };

    this.GetValue = function (name) {
        if (typeof this[name] === "undefined")
            return null;
        return this[name];
    };

    this.GetObjArr = function () {
        if (this._reserved._objArr.length == 0) {
            var arr = [];
            for (k in this) {
                if (this.hasOwnProperty(k))
                    if (k != "_reserved")
                        arr.push({
                            Name: k,
                            Value: this[k]
                        });
            }
            this._reserved._objArr = arr;
        }
        return this._reserved._objArr;
    };

    this.GetNamesArr = function () {
        if (this._reserved._namesArr.length == 0) {
            var arr = [];
            for (k in this) {
                if (this.hasOwnProperty(k))
                    if (k != "_reserved")
                        arr.push(k);
            }
            this._reserved._namesArr = arr;
        }
        return this._reserved._namesArr;
    };

    this.GetValuesArr = function () {
        if (this._reserved._valuesArr.length == 0) {
            var arr = [];
            for (k in this) {
                if (this.hasOwnProperty(k))
                    if (k != "_reserved")
                        arr.push(this[k]);
            }
            this._reserved._valuesArr = arr;
        }
        return this._reserved._valuesArr;
    };

    this.GetSelectOptionsHTML = function () {
        if (this._reserved._selectOptionsHTML.length == 0) {
            var html = "";
            for (k in this) {
                if (this.hasOwnProperty(k))
                    if (k != "_reserved")
                        html += "<option value='" + this[k] + "'>" + k + "</option>";
            }
            this._reserved._selectOptionsHTML = html;
        }
        return this._reserved._selectOptionsHTML;
    };
}).call(Enum.prototype);

您可以这样初始化：

var enum1 = new Enum({
    item1: 0,
    item2: 1,
    item3: 2
});

要获取值（如C#中的枚举）：

var val2 = enum1.item2;

要获取某个值的名称（将相同的值用于不同的名称时可能会不明确）：

var name1 = enum1.GetName(0);  // "item1"

要获取对象中每个名称和值的数组，请执行以下操作：

var arr = enum1.GetObjArr();

将生成：

[{ Name: "item1", Value: 0}, { ... }, ... ]

您还可以轻松获得html选择选项：

var html = enum1.GetSelectOptionsHTML();

其中包含：

"<option value='0'>item1</option>..."