在大多数现代浏览器中，有一种符号基元数据类型，可用于创建枚举。它将确保枚举的类型安全，因为JavaScript保证每个符号值都是唯一的，即symbol（）！=符号（）。例如：

const COLOR = Object.freeze({RED: Symbol(), BLUE: Symbol()});

为了简化调试，可以向枚举值添加描述：

const COLOR = Object.freeze({RED: Symbol("RED"), BLUE: Symbol("BLUE")});

Plunker演示

在GitHub上，您可以找到一个包装器，它简化了初始化枚举所需的代码：

const color = new Enum("RED", "BLUE")

color.RED.toString() // Symbol(RED)
color.getName(color.RED) // RED
color.size // 2
color.values() // Symbol(RED), Symbol(BLUE)
color.toString() // RED,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=状态；

更新05.11.2020：修改为包含静态字段和方法，以更接近地复制“true”枚举行为。

是否有人尝试过使用包含私有字段和“get”访问器的类执行此操作？我意识到私有类字段目前仍处于实验阶段，但它似乎可以用于创建具有不可变字段/财产的类。浏览器支持也不错。唯一不支持它的“主要”浏览器是Firefox（我相信他们很快就会支持）和IE（谁在乎）。

免责声明：我不是一个开发者。我只是在寻找这个问题的答案，并开始思考我有时如何通过创建带有私有字段和受限属性访问器的类来在C#中创建“增强”枚举。

样本类别

class Sizes {
    // Private Fields
    static #_SMALL = 0;
    static #_MEDIUM = 1;
    static #_LARGE = 2;

    // Accessors for "get" functions only (no "set" functions)
    static get SMALL() { return this.#_SMALL; }
    static get MEDIUM() { return this.#_MEDIUM; }
    static get LARGE() { return this.#_LARGE; }
}

现在您应该可以直接调用enums。

Sizes.SMALL; // 0
Sizes.MEDIUM; // 1
Sizes.LARGE; // 2

使用私有字段和有限访问器的组合意味着枚举值得到了很好的保护。

Sizes.SMALL = 10 // Sizes.SMALL is still 0
Sizes._SMALL = 10 // Sizes.SMALL is still 0
Sizes.#_SMALL = 10 // Sizes.SMALL is still 0

我认为它很容易使用。https://stackoverflow.com/a/32245370/4365315

var A = {a:11, b:22}, 
enumA = new TypeHelper(A);

if(enumA.Value === A.b || enumA.Key === "a"){ 
... 
}

var keys = enumA.getAsList();//[object, object]

//set
enumA.setType(22, false);//setType(val, isKey)

enumA.setType("a", true);

enumA.setTypeByIndex(1);

更新：

这是我的助手代码（TypeHelper）。

var助手={isEmpty：函数（obj）{回来obj | | obj===null | | obj===未定义| | Array.isArray（obj）&&obj.length===0；},isObject：函数（obj）{return（对象类型==“object”）；},sortObjectKeys:函数（对象）{return Object.keys（对象）.sort（函数（a，b）{c=a-b；返回c});},containsItem:函数（arr，item）{if（arr&&Array.isArray（arr））{return arr.indexOf（项）>-1；}其他{返回arr==项；}},pushArray：函数（arr1，arr2）{if（arr1&&arr2&&Array.isArray（arr1））{arr1.push.apply（arr1，Array.isArray（arr2）？arr2:[arr2]）；}}};函数TypeHelper（）{var_types=参数[0]，_defTypeIndex＝0，_电流类型，_值，_allKeys=助手.sortObjectKeys（_types）；if（arguments.length==2）{_defTypeIndex=参数[1]；}对象定义属性（this{关键字：{get:函数（）{return _currentType；},集合：函数（val）{_currentType.setType（val，true）；},可枚举：真},值：{get:函数（）{返回类型[_currentType]；},集合：函数（val）{_value.setType（val，false）；},可枚举：真}});this.getAsList=函数（键）{var列表=[]；_allKeys.forEach（函数（键、idx、数组）{if（键和类型[key]）{if（！Helper.isEmpty（keys）&&Helper.containsItem（keys，key）|| Helper.isEmpty（key））{var json=｛｝；json.Key=密钥；json.Value=_types[key]；Helper.pushArray（列表，json）；}}});返回列表；};this.setType=函数（值，isKey）{if（！Helper.isEmpty（value））{Object.keys（_types）.forEach（函数（key，idx，array）{if（Helper.isObject（值））{if（value&&value.Key==Key）{_currentType=键；}}else if（isKey）{if（value&&value.toString（）==key.toString（））{_currentType=键；}}否则如果（value&&value.toString（）==_types[key]）{_currentType=键；}});}其他{this.setDefaultType（）；}return isKey_类型[_currentType]：_currentType；};this.setTypeByIndex=函数（索引）{对于（变量i=0；i<_allKeys.length；i++）{如果（索引==i）{_currentType=_allKeys[index]；打破}}};this.setDefaultType=函数（）{this.setTypeByIndex（_defTypeIndex）；};this.setDefaultType（）；}变量类型A={“-1”：“任意”，“2”：“2L”，“100”：“100L”，“200”：“200L”，“1000”：“1000升”};var enumA=新的TypeHelper（TypeA，4）；document.writeln（“Key=”，enumA.Key，”，Value=“，enumA.Value，”<br>“）；enumA.setType（“200L”，假）；document.writeln（“Key=”，enumA.Key，”，Value=“，enumA.Value，”<br>“）；enumA.setDefaultType（）；document.writeln（“Key=”，enumA.Key，”，Value=“，enumA.Value，”<br>“）；enumA.setTypeByIndex（1）；document.writeln（“Key=”，enumA.Key，”，Value=“，enumA.Value，”<br>“）；document.writeln（“等于=”，（enumA.Value==TypeA[“2”]））；

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

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

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

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

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

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

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