更新

我认为我下面的答案不再是用JavaScript编写枚举的最佳方法。有关更多详细信息，请参阅我的博客文章：JavaScript中的枚举。

已经可以提醒名称：

if (currentColor == my.namespace.ColorEnum.RED) {
   // alert name of currentColor (RED: 0)
   var col = my.namespace.ColorEnum;
   for (var name in col) {
     if (col[name] == col.RED)
       alert(name);
   }
}

或者，您可以创建值对象，这样您就可以吃蛋糕了：

var SIZE = {
  SMALL : {value: 0, name: "Small", code: "S"}, 
  MEDIUM: {value: 1, name: "Medium", code: "M"}, 
  LARGE : {value: 2, name: "Large", code: "L"}
};

var currentSize = SIZE.MEDIUM;
if (currentSize == SIZE.MEDIUM) {
  // this alerts: "1: Medium"
  alert(currentSize.value + ": " + currentSize.name);
}

在JavaScript中，因为它是一种动态语言，所以以后甚至可以向集合中添加枚举值：

// Add EXTRALARGE size
SIZE.EXTRALARGE = {value: 3, name: "Extra Large", code: "XL"};

记住，枚举的字段（本例中的值、名称和代码）不需要用于身份检查，只是为了方便。此外，大小属性本身的名称不需要硬编码，也可以动态设置。因此，假设您只知道新枚举值的名称，您仍然可以毫无问题地添加它：

// Add 'Extra Large' size, only knowing it's name
var name = "Extra Large";
SIZE[name] = {value: -1, name: name, code: "?"};

当然，这意味着无法再进行某些假设（例如，该值表示大小的正确顺序）。

记住，在JavaScript中，对象就像一个映射或哈希表。一组名称值对。你可以在事先不了解它们的情况下循环浏览它们或以其他方式操纵它们。

实例

for (var sz in SIZE) {
  // sz will be the names of the objects in SIZE, so
  // 'SMALL', 'MEDIUM', 'LARGE', 'EXTRALARGE'
  var size = SIZE[sz]; // Get the object mapped to the name in sz
  for (var prop in size) {
    // Get all the properties of the size object, iterates over
    // 'value', 'name' and 'code'. You can inspect everything this way.        
  }
} 

顺便说一句，如果你对名称空间感兴趣，你可能想看看我为JavaScript提供的简单但强大的名称空间和依赖关系管理的解决方案：Packages JS

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

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（音乐样式）

export const ButtonType = Object.freeze({ 
   DEFAULT: 'default', 
   BIG: 'big', 
   SMALL: 'small'
})

来源：https://medium.com/@idanlevi2/enum-in-javascript-5f2ff500f149

我也在寻找这个问题的答案，并找到了这一页的答案，我认为答案与这里的大多数答案不同：https://www.sohamkamani.com/javascript/enums/

我将把文章的答案部分复制到这里，以防将来链接无效或其他情况：

带符号的枚举：符号让我们定义保证不会冲突的值彼此之间。例如：

const Summer1 = Symbol("summer")
const Summer2 = Symbol("summer")

// Even though they have the same apparent value
// Summer1 and Summer2 don't equate
console.log(Summer1 === Summer2)
// false

console.log(Summer1)

我们可以使用符号定义枚举，以确保它们不是复制：

const Summer = Symbol("summer")
const Autumn = Symbol("autumn")
const Winter = Symbol("winter")
const Spring = Symbol("spring")

let season = Spring

switch (season) {
    case Summer:
    console.log('the season is summer')
    break;
    case Winter:
    console.log('the season is winter')
    break;
    case Spring:
    console.log('the season is spring')
    break;
    case Autumn:
    console.log('the season is autumn')
    break;
    default:
    console.log('season not defined')
}

使用Symbol可以确保我们分配枚举值的唯一方法是使用我们最初定义的常量。

具有类的枚举：

为了使代码更加语义正确，我们可以创建一个类保存一组枚举。例如，我们的季节应该有一种方法来识别它们都属于类似的分类。让我们看看如何使用类和对象创建不同的枚举组：

// Season enums can be grouped as static members of a class
class Season {
  // Create new instances of the same class as static attributes
  static Summer = new Season("summer")
  static Autumn = new Season("autumn")
  static Winter = new Season("winter")
  static Spring = new Season("spring")

  constructor(name) {
    this.name = name
  }
}

// Now we can access enums using namespaced assignments
// this makes it semantically clear that "Summer" is a "Season"
let season = Season.Summer

// We can verify whether a particular variable is a Season enum
console.log(season instanceof Season)
// true
console.log(Symbol('something') instanceof Season)
//false

// We can explicitly check the type based on each enums class
console.log(season.constructor.name)
// 'Season'

个人注意：我本应该使用此构造函数：（注意：将this.name设置为字符串而不是对象，会丢失以下一些验证。可以选择删除：.description。我还想找到一种方法，不必键入Seasons.summer.name，而只需：Seasons.summer即可使其返回字符串）

  constructor(name) {
    this.name = Symbol(name).description
  }

列出所有可能的枚举值：

如果我们使用上述基于类的方法Season类的键，以获取同一类下的所有枚举值组：

Object.keys(Season).forEach(season => console.log("season:", season))
// season: Summer
// season: Autumn
// season: Winter
// season: Spring

何时在Javascript中使用枚举？

通常，如果有一定数量的固定任何一个变量的值_例如，Node.js的加密标准库有一个受支持的算法列表，可以将其视为枚举组。正确使用Javascript中的enums将产生更好的代码更稳定、更容易阅读和更少出错。

我一直在摆弄这个，因为我喜欢我的遗珠

使用Object.defineProperty，我想我找到了一个可行的解决方案。

这里有一个jsfiddle：http://jsfiddle.net/ZV4A6/

使用此方法。。理论上，您应该能够为任何对象调用和定义枚举值，而不会影响该对象的其他属性。

Object.defineProperty(Object.prototype,'Enum', {
    value: function() {
        for(i in arguments) {
            Object.defineProperty(this,arguments[i], {
                value:parseInt(i),
                writable:false,
                enumerable:true,
                configurable:true
            });
        }
        return this;
    },
    writable:false,
    enumerable:false,
    configurable:false
}); 

由于属性可写：false，这应该使其类型安全。

因此，您应该能够创建一个自定义对象，然后对其调用Enum（）。分配的值从0开始，每项递增。

var EnumColors={};
EnumColors.Enum('RED','BLUE','GREEN','YELLOW');
EnumColors.RED;    // == 0
EnumColors.BLUE;   // == 1
EnumColors.GREEN;  // == 2
EnumColors.YELLOW; // == 3

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

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

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