What is the preferred syntax for defining enums in JavaScript

Question

What is the preferred syntax for defining enums in JavaScript  Something like   my namespace ColorEnum         RED   0      GREEN   1      BLUE   2       later on  if currentColor    my namespace ColorEnum RED          whatever     Or is there a more preferable idiom

User · Answer

Update 05 11 2020  Modified to include static fields and methods to closer replicate  quot true quot  enum behavior  Has anyone tried doing this with a class that contains private fields and  quot get quot  accessors  I realize private class fields are still experimental at this point but it seems to work for the purposes of creating a class with immutable fields properties  Browser support is decent as well  The only  quot major quot  browsers that don t support it are Firefox  which I m sure they will soon  and IE  who cares   DISCLAIMER  I am not a developer  I was just looking for an answer to this question and started thinking about how I sometimes create  quot enhanced quot  enums in C  by creating classes with private fields and restricted property accessors  Sample Class class Sizes          Private Fields     static   SMALL   0      static   MEDIUM   1      static   LARGE   2          Accessors for  quot get quot  functions only  no  quot set quot  functions      static get SMALL     return this   SMALL        static get MEDIUM     return this   MEDIUM        static get LARGE     return this   LARGE       You should now be able to call your enums directly  Sizes SMALL     0 Sizes MEDIUM     1 Sizes LARGE     2  The combination of using private fields and limited accessors means that the enum values are well protected  Sizes SMALL   10    Sizes SMALL is still 0 Sizes  SMALL   10    Sizes SMALL is still 0 Sizes   SMALL   10    Sizes SMALL is still 0

User · Answer

your answers are far too complicated  var buildSet   function array      var set         for  var i in array        var item   array i       set item    item        return set     var myEnum   buildSet   RED   GREEN   BLUE        myEnum RED     RED     etc

User · Answer

Here s what we all want   function Enum constantsList        for  var i in constantsList            this constantsList i     i            Now you can create your enums   var YesNo   new Enum   NO    YES     var Color   new Enum   RED    GREEN    BLUE       By doing this  constants can be acessed in the usual way  YesNo YES  Color GREEN  and they get a sequential int value  NO   0  YES   1  RED   0  GREEN   1  BLUE   2    You can also add methods  by using Enum prototype   Enum prototype values   function         return this allValues         for the above to work  you d need to do             this allValues   constantsList at the constructor          Edit - small improvement - now with varargs   unfortunately it doesn t work properly on IE  S    should stick with previous version then   function Enum         for  var i in arguments            this arguments i     i           var YesNo   new Enum  NO    YES    var Color   new Enum  RED    GREEN    BLUE

User · Answer

Here s a couple different ways to implement TypeScript enums   The easiest way is to just iterate over an object  adding inverted key-value pairs to the object  The only drawback is that you must manually set the value for each member   function  enum list             for  var key in list        list list key    list key     key        return Object freeze list      var Color    enum     Red  0    Green  5    Blue  2         Color    0   Red   2   Blue   5   Green    Red   0   Green   5   Blue   2     Color Red   0    Color Green   5    Color Blue   2    Color 5    Green    Color Blue  gt  Color Green   false    And here s a lodash mixin to create an enum using a string  While this version is a little bit more involved  it does the numbering automatically for you  All the lodash methods used in this example have a regular JavaScript equivalent  so you can easily switch them out if you want   function enum         var key  val   -1  list             reduce   toArray arguments   function result  kvp                kvp   kvp split               key     trim kvp 0            val     parseInt kvp 1        val                      result result val    key    val          return result         list       return Object freeze list             Add enum to lodash    mixin    enum   enum      var Color     enum       Red        Green        Blue   5        Yellow        Purple   20        Gray         Color Red   0    Color Green   1    Color Blue   5    Color Yellow   6    Color Purple   20    Color Gray   21    Color 5    Blue

User · Answer

Since 1 8 5 it s possible to seal and freeze the object  so define the above as  const DaysEnum   Object freeze   quot monday quot  1   quot tuesday quot  2   quot wednesday quot  3         or const DaysEnum     quot monday quot  1   quot tuesday quot  2   quot wednesday quot  3       Object freeze DaysEnum   and voila  JS enums  However  this doesn t prevent you from assigning an undesired value to a variable  which is often the main goal of enums  let day   DaysEnum tuesday day   298832342    goes through without any errors  One way to ensure a stronger degree of type safety  with enums or otherwise  is to use a tool like TypeScript or Flow  Quotes aren t needed but I kept them for consistency

User · Answer

I wasn t satisfied with any of the answers  so I made Yet Another Enum  YEA     This implementation    uses more up-to-date JS requires just the declaration of this one class to easily create enums has mapping by name  colors RED   string  colors  RED     and index  colors 0    but you only need to pass in the strings as an array binds equivalent toString   and valueOf   functions to each enum object  if this is somehow not desired  one can simply remove it - small overhead for JS though  has optional global naming storage by name string freezes the enum object once created so that it can t be modified   Special thanks to Andre  Fi  s answer for some inspiration     The codes   class Enums     static create   name   undefined  items               let newEnum           newEnum length   items length      newEnum items   items      for  let itemIndex in items            Map by name        newEnum items itemIndex     parseInt itemIndex  10           Map by index        newEnum parseInt itemIndex  10     items itemIndex             newEnum toString   Enums enumToString bind newEnum       newEnum valueOf   newEnum toString        Optional naming and global registration      if  name    undefined          newEnum name   name        Enums name    newEnum              Prevent modification of the enum object      Object freeze newEnum       return newEnum        static enumToString         return  Enum            this name    undefined   this name                           this items toString                    Usage   let colors   Enums create     name   COLORS     items     RED    GREEN    BLUE    PORPLE           Global access  if named  Enums COLORS   colors items    Array 4     RED    GREEN    BLUE    PORPLE    colors length    4  colors RED    0 colors GREEN    1 colors BLUE    2 colors PORPLE    3 colors 0      RED  colors 1      GREEN  colors 2      BLUE  colors 3      PORPLE   colors toString       Enum COLORS  RED GREEN BLUE PORPLE      Enum frozen  makes it a real enum  colors RED   9001  colors RED    0

User · Answer

I ve just published an NPM package gen enum allows you to create Enum data structure in Javascript quickly   var genEnum   require  gen enum     var AppMode   genEnum  SIGN UP  LOG IN  FORGOT PASSWORD    var curMode   AppMode LOG IN  console log curMode isLogIn        output true  console log curMode isSignUp        output false  console log curMode isForgotPassword        output false    One nice thing about this little tool is in modern environment  including nodejs and IE 9  browsers  the returned Enum object is immutable   For more information please checkout https   github com greenlaw110 enumjs  Updates  I obsolete gen enum package and merge the function into constjs package  which provides more features including immutable objects  JSON string deserialization  string constants and bitmap generation etc  Checkout https   www npmjs com package constjs for more information   To upgrade from gen enum to constjs just change the statement  var genEnum   require  gen enum      to  var genEnum   require  constjs   enum

User · Answer

Use Javascript Proxies  TLDR  Add this class to your utility methods and use it throughout your code  it mocks Enum behavior from traditional programming languages  and actually throws errors when you try to either access an enumerator that does not exist or add update an enumerator  No need to rely on Object freeze     class Enum     constructor enumObj        const handler           get target  name            if  typeof target name      undefined               return target name                     throw new Error  No such enumerator    name                    set             throw new Error  Cannot add update properties on an Enum instance after it is defined                       return new Proxy enumObj  handler           Then create enums by instantiating the class   const roles   new Enum     ADMIN   Admin     USER   User           Full Explanation    One very beneficial feature of Enums that you get from traditional languages is that they blow up  throw a compile-time error  if you try to access an enumerator which does not exist    Besides freezing the mocked enum structure to prevent additional values from accidentally maliciously being added  none of the other answers address that intrinsic feature of Enums   As you are probably aware  accessing non-existing members in JavaScript simply returns undefined and does not blow up your code  Since enumerators are predefined constants  i e  days of the week   there should never be a case when an enumerator should be undefined   Don t get me wrong  JavaScript s behavior of returning undefined when accessing undefined properties is actually a very powerful feature of language  but it s not a feature you want when you are trying to mock traditional Enum structures    This is where Proxy objects shine  Proxies were standardized in the language with the introduction of ES6  ES2015   Here s the description from MDN       The Proxy object is used to define custom behavior for fundamental operations  e g  property lookup  assignment  enumeration  function   invocation  etc     Similar to a web server proxy  JavaScript proxies are able to intercept operations on objects  with the use of  traps   call them hooks if you like  and allow you to perform various checks  actions and or manipulations before they complete  or in some cases stopping the operations altogether which is exactly what we want to do if and when we try to reference an enumerator which does not exist    Here s a contrived example that uses the Proxy object to mimic Enums  The enumerators in this example are standard HTTP Methods  i e   GET    POST   etc      x000D   x000D     Class for creating enums  13 lines  x000D     Feel free to add this to your utility library in  x000D     your codebase and profit  Note  As Proxies are an ES6  x000D     feature  some browsers clients may not support it and  x000D     you may need to transpile using a service like babel x000D   x000D  class Enum   x000D       The Enum class instantiates a JavaScript Proxy object  x000D       Instantiating a  Proxy  object requires two parameters   x000D       a  target  object and a  handler   We first define the handler  x000D       then use the handler to instantiate a Proxy  x000D   x000D       A proxy handler is simply an object whose properties x000D       are functions which define the behavior of the proxy  x000D       when an operation is performed on it   x000D     x000D       For enums  we need to define behavior that lets us check what enumerator x000D       is being accessed and what enumerator is being set  This can be done by  x000D       defining  get  and  set  traps  x000D    constructor enumObj    x000D      const handler     x000D        get target  name    x000D          if  typeof target name      undefined     x000D            return target name  x000D            x000D          throw new Error  No such enumerator    name    x000D           x000D        set     x000D          throw new Error  Cannot add update properties on an Enum instance after it is defined   x000D          x000D        x000D   x000D   x000D         Freeze the target object to prevent modifications x000D      return new Proxy enumObj  handler  x000D      x000D    x000D   x000D   x000D     Now that we have a generic way of creating Enums  lets create our first Enum  x000D  const httpMethods   new Enum   x000D    DELETE   DELETE   x000D    GET   GET   x000D    OPTIONS   OPTIONS   x000D    PATCH   PATCH   x000D    POST   POST   x000D    PUT   PUT  x000D     x000D   x000D     Sanity checks x000D  console log httpMethods DELETE  x000D     logs  DELETE  x000D   x000D  try   x000D    httpMethods delete    delete  x000D    catch  e    x000D  console log  Error     e message  x000D    x000D     throws  Cannot add update properties on an Enum instance after it is defined  x000D   x000D  try   x000D    console log httpMethods delete  x000D    catch  e    x000D    console log  Error     e message  x000D    x000D     throws  No such enumerator  delete  x000D   x000D   x000D      ASIDE  What the heck is a proxy   I remember when I first started seeing the word proxy everywhere  it definitely didn t make sense to me for a long time  If that s you right now  I think an easy way to generalize proxies is to think of them as software  institutions  or even people that act as intermediaries or middlemen between two servers  companies  or people

User · Answer

I came up with this approach which is modeled after enums in Java  These are type-safe  and so you can perform instanceof checks as well   You can define enums like this   var Days   Enum define  Days     Monday    Tuesday    Wednesday    Thursday    Friday    Saturday    Sunday       Days now refers to the Days enum   Days Monday instanceof Days     true  Days Friday name        Friday  Days Friday ordinal       4  Days Sunday     Days Sunday     true Days Sunday     Days Friday     false  Days Sunday toString        Sunday   Days toString       Days   Monday  Tuesday  Wednesday  Thursday  Friday  Saturday  Sunday      Days values   map function e    return e name            Monday    Tuesday    Wednesday    Thursday    Friday    Saturday    Sunday   Days values   4  name       Friday   Days fromName  Thursday       Days Thursday    true Days fromName  Wednesday   name       Wednesday  Days Friday fromName  Saturday   name       Saturday    The implementation   var Enum    function                     Function to define an enum         param typeName - The name of the enum          param constants - The constants on the enum  Can be an array of strings  or an object where each key is an enum        constant  and the values are objects that describe attributes that can be attached to the associated constant              function define typeName  constants                 Check Arguments             if  typeof typeName      undefined                 throw new TypeError  A name is required                        if    constants instanceof Array   amp  amp   Object getPrototypeOf constants      Object prototype                  throw new TypeError  The constants parameter must either be an array or an object                else if   constants instanceof Array   amp  amp  constants length     0                 throw new TypeError  Need to provide at least one constant                else if   constants instanceof Array   amp  amp   constants reduce function  isString  element                    return isString  amp  amp   typeof element      string                   true                  throw new TypeError  One or more elements in the constant array is not a string                else if  Object getPrototypeOf constants      Object prototype  amp  amp   Object keys constants  reduce function  isObject  constant                    return Object getPrototypeOf constants constant       Object prototype                 true                  throw new TypeError  One or more constants do not have an associated object-value                         var isArray    constants instanceof Array           var isObject    isArray               Private sentinel-object used to guard enum constructor so that no one else can create enum instances             function                        Dynamically define a function with the same name as the enum we want to define              var   enum   new Function                      return function     typeName     sentinel  name  ordinal                        if   sentinel instanceof                                throw new TypeError   Cannot instantiate an instance of     typeName                                                     this   name   name                      this   ordinal   ordinal                                                 Private objects used to maintain enum instances for values    and to look up enum instances for fromName               var   values               var   dict                    Attach values   and fromName   methods to the class itself  kind of like static methods               Object defineProperty   enum   values                 value  function                      return   values                                     Object defineProperty   enum   fromName                 value  function  name                    var   constant     dict name                  if    constant                        return   constant                    else                       throw new TypeError typeName     does not have a constant with name     name                                                                             The following methods are available to all instances of the enum  values   and fromName   need to be            available to each constant  and so we will attach them on the prototype  But really  they re just            aliases to their counterparts on the prototype                      Object defineProperty   enum prototype   values                 value    enum values                      Object defineProperty   enum prototype   fromName                 value    enum fromName                      Object defineProperty   enum prototype   name                 value  function                      return this   name                                     Object defineProperty   enum prototype   ordinal                 value  function                      return this   ordinal                                     Object defineProperty   enum prototype   valueOf                 value  function                      return this   name                                     Object defineProperty   enum prototype   toString                 value  function                      return this   name                                                    If constants was an array  we can the element values directly  Otherwise  we will have to use the keys            from the constants object                      var  constants   constants          if  isObject                 constants   Object keys constants                          Iterate over all constants  create an instance of our enum for each one  and attach it to the enum type              constants forEach function  name  ordinal                   Create an instance of the enum             var   constant   new   enum new       name  ordinal                   If constants was an object  we want to attach the provided attributes to the instance              if  isObject                    Object keys constants name   forEach function  attr                        Object defineProperty   constant  attr                            value  constants name  attr                                                                            Freeze the instance so that it cannot be modified              Object freeze   constant                   Attach the instance using the provided name to the enum type itself              Object defineProperty   enum  name                    value    constant                                 Update our private objects               values push   constant                 dict name      constant                           Define a friendly toString method for the enum             var string   typeName             enum values   map function  c                    return c name                   join                         Object defineProperty   enum   toString                 value  function                      return string                                         Freeze our private objects             Object freeze   values           Object freeze   dict                Freeze the prototype on the enum and the enum itself             Object freeze   enum prototype           Object freeze   enum                Return the enum             return   enum             return           define  define

User · Answer

In most modern browsers  there is a symbol primitive data type which can be used to create an enumeration  It will ensure type safety of the enum as each symbol value is guaranteed by JavaScript to be unique  i e  Symbol      Symbol    For example   const COLOR   Object freeze  RED  Symbol    BLUE  Symbol        To simplify debugging  you can add a description to enum values   const COLOR   Object freeze  RED  Symbol  RED    BLUE  Symbol  BLUE        Plunker demo  On GitHub you can find a wrapper that simplifies the code required to initialize the enum   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

User · Answer

The com recoyxgroup javascript enum package allows you to properly define enum and flags enum classes  where   Every constant is represented as an immutable    value  someNumber   Every constant has a property attached to the enum class  E CONSTANT NAME  Every constant has a friendly String  constantName  Every constant has a Number  someNumber  You can declare custom properties methods using E prototype   Wherever a specific enum is expected  the convention is to do E v   like this  const   FlagsEnum   from  com recoyxgroup javascript enum    const Rights   FlagsEnum  Rights          ADMINISTRATION        REVIEW        function fn rights        rights   Rights rights       console log  administration  in rights   review  in rights      fn    administration    review         true true fn   administration        true false fn  undefined       false false  var r   Rights ADMINISTRATION  console log  r     administration      As you can see  you can still compare the value to a String  Definitions can be more specific  const E   FlagsEnum  E           Q   0x10         K    someB          L    0x40   someL          FlagsEnum products  gt  Instance properties methods  number  was going to be valueOf    but because of JS     had to be  number   set   exclude   toggle   filter   valueOf   toString

User · Answer

var DaysEnum   Object freeze    monday      tuesday                You don t need to specify an id  you can just use an empty object to compare enums    if  incommingEnum     DaysEnum monday    incommingEnum is monday   EDIT  If you are going to serialize the object  to JSON for instance  you ll the id again      taken from Gabriel Llamas comment     edit based on Stijn de Witt s comment

User · Answer

export const ButtonType   Object freeze       DEFAULT   default       BIG   big       SMALL   small      source  https   medium com  idanlevi2 enum-in-javascript-5f2ff500f149

User · Answer

This isn t much of an answer  but I d say that works just fine  personally  Having said that  since it doesn t matter what the values are  you ve used 0  1  2   I d use a meaningful string in case you ever wanted to output the current value

User · Answer

Here s a couple different ways to implement TypeScript enums   The easiest way is to just iterate over an object  adding inverted key-value pairs to the object  The only drawback is that you must manually set the value for each member   function  enum list             for  var key in list        list list key    list key     key        return Object freeze list      var Color    enum     Red  0    Green  5    Blue  2         Color    0   Red   2   Blue   5   Green    Red   0   Green   5   Blue   2     Color Red   0    Color Green   5    Color Blue   2    Color 5    Green    Color Blue  gt  Color Green   false    And here s a lodash mixin to create an enum using a string  While this version is a little bit more involved  it does the numbering automatically for you  All the lodash methods used in this example have a regular JavaScript equivalent  so you can easily switch them out if you want   function enum         var key  val   -1  list             reduce   toArray arguments   function result  kvp                kvp   kvp split               key     trim kvp 0            val     parseInt kvp 1        val                      result result val    key    val          return result         list       return Object freeze list             Add enum to lodash    mixin    enum   enum      var Color     enum       Red        Green        Blue   5        Yellow        Purple   20        Gray         Color Red   0    Color Green   1    Color Blue   5    Color Yellow   6    Color Purple   20    Color Gray   21    Color 5    Blue

User · Answer

Here s my take on a  flagged  Enum factory  Here s a working demo        Notes      The proxy handler enables case insensitive property queries    BigInt is used to enable bitflag strings  w length  gt  52    function EnumFactory       const proxyfy         construct target  args           const caseInsensitiveHandler                get target  key              return target key toUpperCase       target key                               const proxified   new Proxy new target    args   caseInsensitiveHandler           return Object freeze proxified                const ProxiedEnumCtor   new Proxy EnumCtor  proxyfy     const throwIf           assertion   false         message    Unspecified error          ErrorType   Error     gt         assertion  amp  amp        gt    throw new ErrorType message           const hasFlag    val  sub    gt        throwIf  val     sub   quot valueIn  missing parameters quot   RangeError       const andVal    sub  amp  val       return andVal     BigInt 0   amp  amp  andVal     val          function EnumCtor values        throwIf values constructor     Array                 values length  lt  2             values filter  v   gt  v constructor     String   length  gt  0         EnumFactory  expected Array of at least 2 strings   TypeError       const base   BigInt 1       this NONE   BigInt 0       values forEach   v  i    gt  this v toUpperCase      base lt  lt BigInt i            EnumCtor prototype         get keys     return Object keys this  slice 1          subset sub          const arrayValues   this keys        return new ProxiedEnumCtor              sub toString 2   reverse              reduce   acc  v  i    gt     v  lt  1   acc       acc  arrayValues i                               getLabel enumValue          const tryLabel   Object entries this  find  value   gt  value 1      enumValue          return  enumValue     tryLabel length             quot getLabel  no value parameter or value not in enum quot            tryLabel shift               hasFlag val  sub   this    return hasFlag val  sub                return arr   gt  new ProxiedEnumCtor arr

User · Answer

As of writing  October 2014 - so here is a contemporary solution  Am writing the solution as a Node Module  and have included a test using Mocha and Chai  as well as underscoreJS  You can easily ignore these  and just take the Enum code if preferred   Seen a lot of posts with overly convoluted libraries etc  The solution to getting enum support in Javascript is so simple it really isn t needed  Here is the code   File  enums js      require  underscore     var  Enum   function          var keys     map arguments  function  value          return value            var self           keys  keys          for  var i   0  i  lt  arguments length  i            self keys i     i          return self      var fileFormatEnum   Object freeze  Enum  CSV    TSV     var encodingEnum   Object freeze  Enum  UTF8    SHIFT JIS      exports fileFormatEnum   fileFormatEnum  exports encodingEnum   encodingEnum    And a test to illustrate what it gives you   file  enumsSpec js  var chai   require  chai        assert   chai assert      expect   chai expect      should   chai should        enums   require    enums            require  underscore      describe  enums   function           describe  fileFormatEnum   function              it  should return expected fileFormat enum declarations   function                  var fileFormatEnum   enums fileFormatEnum              should exist fileFormatEnum               assert    keys    CSV   TSV    CSV  0  TSV  1       JSON stringify fileFormatEnum    Unexpected format                assert    CSV   TSV        JSON stringify fileFormatEnum keys    Unexpected keys format                             describe  encodingEnum   function              it  should return expected encoding enum declarations   function                  var encodingEnum   enums encodingEnum              should exist encodingEnum               assert    keys    UTF8   SHIFT JIS    UTF8  0  SHIFT JIS  1       JSON stringify encodingEnum    Unexpected format                assert    UTF8   SHIFT JIS        JSON stringify encodingEnum keys    Unexpected keys format                               As you can see  you get an Enum factory  you can get all the keys simply by calling enum keys  and you can match the keys themselves to integer constants  And you can reuse the factory with different values  and export those generated Enums using Node s modular approach    Once again  if you are just a casual user  or in the browser etc  just take the factory part of the code  potentially removing underscore library too if you don t wish to use it in your code

User · Answer

It s easy to use  I think  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     UPDATE   There is my helper codes TypeHelper     x000D   x000D  var Helper     x000D      isEmpty  function  obj    x000D          return  obj    obj     null    obj     undefined    Array isArray obj   amp  amp  obj length     0  x000D         x000D   x000D      isObject  function  obj    x000D          return  typeof obj      object    x000D         x000D   x000D      sortObjectKeys  function  object    x000D          return Object keys object  x000D               sort function  a  b    x000D                  c   a - b  x000D                  return c x000D                  x000D         x000D      containsItem  function  arr  item    x000D          if  arr  amp  amp  Array isArray arr     x000D              return arr indexOf item   gt  -1  x000D            else   x000D              return arr     item  x000D            x000D         x000D   x000D      pushArray  function  arr1  arr2    x000D          if  arr1  amp  amp  arr2  amp  amp  Array isArray arr1     x000D              arr1 push apply arr1  Array isArray arr2    arr2    arr2    x000D            x000D        x000D     x000D  function TypeHelper     x000D      var  types   arguments 0   x000D           defTypeIndex   0  x000D           currentType  x000D           value  x000D           allKeys   Helper sortObjectKeys  types   x000D   x000D      if  arguments length    2    x000D           defTypeIndex   arguments 1   x000D        x000D   x000D      Object defineProperties this    x000D          Key    x000D              get  function      x000D                  return  currentType  x000D                 x000D              set  function  val    x000D                   currentType setType val  true   x000D                 x000D              enumerable  true x000D             x000D          Value    x000D              get  function      x000D                  return  types  currentType   x000D                 x000D              set  function  val    x000D                   value setType val  false   x000D                 x000D              enumerable  true x000D            x000D          x000D      this getAsList   function  keys    x000D          var list       x000D           allKeys forEach function  key  idx  array    x000D              if  key  amp  amp   types key     x000D   x000D                  if   Helper isEmpty keys   amp  amp  Helper containsItem keys  key     Helper isEmpty keys     x000D                      var json       x000D                      json Key   key  x000D                      json Value    types key   x000D                      Helper pushArray list  json   x000D                    x000D                x000D              x000D          return list  x000D         x000D   x000D      this setType   function  value  isKey    x000D          if   Helper isEmpty value     x000D              Object keys  types  forEach function  key  idx  array    x000D                  if  Helper isObject value     x000D                      if  value  amp  amp  value Key    key    x000D                           currentType   key  x000D                        x000D                    else if  isKey    x000D                      if  value  amp  amp  value toString      key toString      x000D                           currentType   key  x000D                        x000D                    else if  value  amp  amp  value toString       types key     x000D                       currentType   key  x000D                    x000D                  x000D            else   x000D              this setDefaultType    x000D            x000D          return isKey    types  currentType     currentType  x000D         x000D   x000D      this setTypeByIndex   function  index    x000D          for  var i   0  i  lt   allKeys length  i      x000D              if  index     i    x000D                   currentType    allKeys index   x000D                  break  x000D                x000D            x000D         x000D   x000D      this setDefaultType   function      x000D          this setTypeByIndex  defTypeIndex   x000D         x000D   x000D      this setDefaultType    x000D    x000D   x000D  var TypeA     x000D       -1    Any   x000D       2    2L   x000D       100    100L   x000D       200    200L   x000D       1000    1000L  x000D     x000D   x000D  var enumA   new TypeHelper TypeA  4   x000D   x000D  document writeln  Key      enumA Key    Value      enumA Value    lt br gt     x000D   x000D   x000D  enumA setType  200L   false   x000D  document writeln  Key      enumA Key    Value      enumA Value    lt br gt     x000D   x000D  enumA setDefaultType    x000D  document writeln  Key      enumA Key    Value      enumA Value    lt br gt     x000D   x000D   x000D  enumA setTypeByIndex 1   x000D  document writeln  Key      enumA Key    Value      enumA Value    lt br gt     x000D   x000D  document writeln  is equals       enumA Value    TypeA  2      x000D   x000D   x000D

User · Answer

UPDATE  Thanks for all the upvotes everyone  but I don t think my answer below is the best way to write enums in JavaScript anymore  See my blog post for more details  Enums in JavaScript     Alerting the name is already possible   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            Alternatively  you could make the values objects  so you can have the cake and eat it too   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       In JavaScript  as it is a dynamic language  it is even possible to add enum values to the set later      Add EXTRALARGE size SIZE EXTRALARGE    value  3  name   Extra Large   code   XL      Remember  the fields of the enum  value  name and code in this example  are not needed for the identity check and are only there for convenience  Also the name of the size property itself does not need to be hard coded  but can also be set dynamically  So supposing you only know the name for your new enum value  you can still add it without problems      Add  Extra Large  size  only knowing it s name var name    Extra Large   SIZE name     value  -1  name  name  code          Of course this means that some assumptions can no longer be made  that value represents the correct order for the size for example     Remember  in JavaScript an object is just like a map or hash table  A set of name-value pairs  You can loop through them or otherwise manipulate them without knowing much about them in advance   Example  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                   And by the way  if you are interested in namespaces  you may want to have a look at my solution for simple but powerful namespace and dependency management for JavaScript  Packages JS

User · Answer

This isn t much of an answer  but I d say that works just fine  personally  Having said that  since it doesn t matter what the values are  you ve used 0  1  2   I d use a meaningful string in case you ever wanted to output the current value

User · Answer

Really like what  Duncan did above  but I don t like mucking up global Object function space with Enum  so I wrote the following   function mkenum 1       var o   new Object      var c   -1    var f   function e  v    Object defineProperty o  e    value v  writable false  enumerable true  configurable true         for  i in arguments        var e   arguments i       if     e   amp   e constructor    Object         for  j in e          f j   c e j         else       f e    c            return Object freeze   Object freeze o    o     var Sizes   mkenum 1  SMALL   MEDIUM   LARGE  100   XLARGE     console log  MED        Sizes MEDIUM   console log  LRG        Sizes LARGE       Output is     MED    1    LRG    100    Stijin also has a neat solution  referring to his blog  which includes properties on these objects  I wrote some code for that  too  which I m including next   function mkenum 2 seed        var p            console log  Seed        seed        for  k in seed            var v   seed k            if  v instanceof Array              p  seed k  v 0        value  v 0   name  v 1   code  v 2             else             p v      value  v  name  k toLowerCase    code  k substring 0 1               seed properties   p       return Object freeze   Object freeze seed    seed      This version produces an additional property list allowing friendly name conversion and short codes   I like this version because one need not duplicate data entry in properties as the code does it for you   var SizeEnum2   mkenum 2   SMALL  1  MEDIUM  2  LARGE  3    var SizeEnum3   mkenum 2   SMALL   1   small    S    MEDIUM   2   medium    M    LARGE   3   large    L         These two can be combined into a single processing unit  mkenum   consume enums  assign values  create and add property list    However  as I ve spent far too much time on this today already  I will leave the combination as an exercise for the dear reader

User · Answer

Read all the answers and didn t found any non-verbose and DRY solution  I use this one-liner   const modes     DRAW    SCALE    DRAG   reduce  o  v    gt        o   v   v            it generates an object with human-readable values       DRAW   DRAW     SCALE   SCALE     DRAG   DRAG

User · Answer

I wrote enumerationjs a very tiny library to address the issue which ensures type safety  allow enum constants to inherit from a prototype  guaranties enum constants and enum types to be immutable   many little features  It allows to refactor a lot of code and move some logic inside the enum definition  Here is an example     var CloseEventCodes   new Enumeration  closeEventCodes       CLOSE NORMAL              id  1000  info   Connection closed normally       CLOSE GOING AWAY          id  1001  info   Connection closed going away       CLOSE PROTOCOL ERROR      id  1002  info   Connection closed due to protocol error        CLOSE UNSUPPORTED         id  1003  info   Connection closed due to unsupported operation       CLOSE NO STATUS           id  1005  info   Connection closed with no status       CLOSE ABNORMAL            id  1006  info   Connection closed abnormally       CLOSE TOO LARGE           id  1009  info   Connection closed due to too large packet        talk  function        console log this info              CloseEventCodes CLOSE TOO LARGE talk      prints  Connection closed due to too large packet  CloseEventCodes CLOSE TOO LARGE instanceof CloseEventCodes   evaluates to true   Enumeration is basically a factory    Fully documented guide available here  Hope this helps

User · Answer

This isn t much of an answer  but I d say that works just fine  personally  Having said that  since it doesn t matter what the values are  you ve used 0  1  2   I d use a meaningful string in case you ever wanted to output the current value

User · Answer

export const ButtonType   Object freeze       DEFAULT   default       BIG   big       SMALL   small      source  https   medium com  idanlevi2 enum-in-javascript-5f2ff500f149

User · Answer

In most modern browsers  there is a symbol primitive data type which can be used to create an enumeration  It will ensure type safety of the enum as each symbol value is guaranteed by JavaScript to be unique  i e  Symbol      Symbol    For example   const COLOR   Object freeze  RED  Symbol    BLUE  Symbol        To simplify debugging  you can add a description to enum values   const COLOR   Object freeze  RED  Symbol  RED    BLUE  Symbol  BLUE        Plunker demo  On GitHub you can find a wrapper that simplifies the code required to initialize the enum   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

User · Answer

This is the solution that I use   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  lt  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  gt   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      And you define your enums like this   var COLORS   defineEnum       RED             value   1          string    red             GREEN             value   2          string    green             BLUE             value   3          string    blue              And this is how you access your enums   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       I usually use the last 2 methods for mapping enums from message objects   Some advantages to this approach    Easy to declare enums Easy to access your enums Your enums can be complex types The Enum class has some associative caching if you are using getByValue a lot   Some disadvantages    Some messy memory management going on in there  as I keep the references to the enums Still no type safety

User · Answer

You could also try to define a new function and therebefore a new namespace  and add variables to it  like this  function Color          Color RED   1  Color YELLOW   2   As long anybody uses the namespace granted by the function Color  everything will go fine  If you know Java  this is kind of old enums   where we use a class or interface only to hold static attributes  If a function  in javascript  is a kind of class  this is pretty much the same approach  I thing is a very simple way to define enums  Hope it helps  Greetings  Victor

User · Answer

The Alien solution is to make things as simple as possible    use enum keyword  reserved in javascript  If enum keyword is just reserved but not implemented in your javascript  define the following  const enumerate   spec   gt  spec split   s   s       reduce  e  n    gt  Object assign e   n  n            Now  you can easily use it  const kwords   enumerate  begin end  procedure if   console log kwords  kwords if  kwords if     if   kwords undef    I see no reason to make the enum values explicit variables  The scripts are morphic anyway and it makes no difference if part of your code is a string or valid code  What really matters is that you do not need to deal with tons of quotation marks whenever use or define them

User · Answer

I ve been playing around with this  as I love my enums      Using Object defineProperty I think I came up with a somewhat viable solution   Here s a jsfiddle  http   jsfiddle net ZV4A6   Using this method   you should  in theory  be able to call and define enum values for any object  without affecting other attributes of that object   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        Because of the attribute writable false this should make it type safe   So you should be able to create a custom object  then call Enum   on it  The values assigned start at 0 and increment per item   var EnumColors     EnumColors Enum  RED   BLUE   GREEN   YELLOW    EnumColors RED           0 EnumColors BLUE          1 EnumColors GREEN         2 EnumColors YELLOW        3

User · Answer

You can use Object prototype hasOwnProperty      x000D   x000D  var findInEnum  x000D      colorEnum     x000D      red   0  x000D      green   1  x000D      blue   2 x000D     x000D   x000D     later on x000D   x000D  findInEnum   function  enumKey    x000D    if  colorEnum hasOwnProperty enumKey     x000D      return enumKey   Value      colorEnum enumKey  x000D      x000D    x000D   x000D  alert findInEnum  blue    x000D   x000D   x000D

User · Answer

You could try using https   bitbucket org snippets frostbane aAjxM   my namespace ColorEnum   new Enum       RED   0        GREEN        BLUE      It should work up to ie8

User · Answer

Create an object literal   const Modes       DRAGGING   drag     SCALING    scale     CLICKED    click

User · Answer

You can do something like this      var Enum    function foo         var EnumItem   function item           if typeof item     string                this name   item            else               this name   item name                      EnumItem prototype   new String  DEFAULT        EnumItem prototype toString   function            return this name            EnumItem prototype equals   function item           if typeof item     string                return this name    item            else               return this    item  amp  amp  this name    item name                       function Enum             this add apply this  arguments           Object freeze this             Enum prototype add   function             for  var i in arguments                var enumItem   new EnumItem arguments i                this enumItem name    enumItem                       Enum prototype toList   function             return Object keys this              foo Enum   Enum      return Enum     this   var STATUS   new Enum  CLOSED   PENDING     name    CONFIRMED   ackd   true     var STATE   new Enum  CLOSED   PENDING   CONFIRMED    name    STARTED     name    PROCESSING       As defined in this library  https   github com webmodule foo blob master foo js L217  Complete example https   gist github com lnt bb13a2fd63cdb8bce85fd62965a20026

User · Answer

The Alien solution is to make things as simple as possible    use enum keyword  reserved in javascript  If enum keyword is just reserved but not implemented in your javascript  define the following  const enumerate   spec   gt  spec split   s   s       reduce  e  n    gt  Object assign e   n  n            Now  you can easily use it  const kwords   enumerate  begin end  procedure if   console log kwords  kwords if  kwords if     if   kwords undef    I see no reason to make the enum values explicit variables  The scripts are morphic anyway and it makes no difference if part of your code is a string or valid code  What really matters is that you do not need to deal with tons of quotation marks whenever use or define them

User · Answer

var ColorEnum         red          green          blue         You don t need to make sure you don t assign duplicate numbers to different enum values this way  A new object gets instantiated and assigned to all enum values

User · Answer

There are basically two types of enums  global  like C  and object-like  like TypeScript   For global enums  do something like this-    Note that    enum is optional  though it makes it look slightly better  const    enum   SUNDAY   1    MONDAY   2    TUESDAY   3    WEDNSDAY   4    THURSDAY   5    FRIDAY   6    SATURDAY   7   And for object-like enums  do this  like Artur Czajka s answer -    A trailing comma isn t required but is a good habit  const Days   Object freeze     SUNDAY   1    MONDAY   2    TUESDAY   3    WEDSNDAY   4    THURSDAY   5    FRIDAY   6    SATURDAY   7       or const Days       SUNDAY   1    MONDAY   2    TUESDAY   3    WEDSNDAY   4    THURSDAY   5    FRIDAY   6    SATURDAY   7     Object freeze Days    The first way to declare object-like enums looks slightly cleaner  By the way  global and object-like enums aren t really correct terms  I made them up  Edit  A solution made  for global enums  by Aral Roca  it looks amazing but has a con of being slow  like 0 1 seconds slow - function  ENUM count   1      while  true  yield count       and then const   RED  GREEN  BLUE     ENUM

User · Answer

es7 way   iterator  freeze   usage   const ThreeWiseMen   new Enum  Melchior    Caspar    Balthazar    for  let name of ThreeWiseMen      console log name       with a given key let key   ThreeWiseMen Melchior  console log key in ThreeWiseMen     true  string conversion  also true   Melchior  in ThreeWiseMen   for  let entry from key enum       console log entry       prevent alteration  throws TypeError in strict mode  ThreeWiseMen Me    Me too   ThreeWiseMen Melchior name    Foo    code   class EnumKey        constructor props    Object freeze Object assign this  props          toString     return this name       export class Enum        constructor    keys             for  let  index  key  of keys entries                   Object defineProperty this  key                     value  new EnumKey   name key  index  enum this                     enumerable  true                                      Object freeze this                Symbol iterator               for  let key of Object keys this               yield this key              toString     return     this  join

User · Answer

You can try this      var Enum   Object freeze               Role  Object freeze   Administrator  1  Manager  2  Supervisor  3                 Color Object freeze  RED   0  GREEN   1  BLUE   2                         alert Enum Role Supervisor       alert Enum Color GREEN       var currentColor 0      if currentColor    Enum Color RED           alert  Its Red

User · Answer

Really like what  Duncan did above  but I don t like mucking up global Object function space with Enum  so I wrote the following   function mkenum 1       var o   new Object      var c   -1    var f   function e  v    Object defineProperty o  e    value v  writable false  enumerable true  configurable true         for  i in arguments        var e   arguments i       if     e   amp   e constructor    Object         for  j in e          f j   c e j         else       f e    c            return Object freeze   Object freeze o    o     var Sizes   mkenum 1  SMALL   MEDIUM   LARGE  100   XLARGE     console log  MED        Sizes MEDIUM   console log  LRG        Sizes LARGE       Output is     MED    1    LRG    100    Stijin also has a neat solution  referring to his blog  which includes properties on these objects  I wrote some code for that  too  which I m including next   function mkenum 2 seed        var p            console log  Seed        seed        for  k in seed            var v   seed k            if  v instanceof Array              p  seed k  v 0        value  v 0   name  v 1   code  v 2             else             p v      value  v  name  k toLowerCase    code  k substring 0 1               seed properties   p       return Object freeze   Object freeze seed    seed      This version produces an additional property list allowing friendly name conversion and short codes   I like this version because one need not duplicate data entry in properties as the code does it for you   var SizeEnum2   mkenum 2   SMALL  1  MEDIUM  2  LARGE  3    var SizeEnum3   mkenum 2   SMALL   1   small    S    MEDIUM   2   medium    M    LARGE   3   large    L         These two can be combined into a single processing unit  mkenum   consume enums  assign values  create and add property list    However  as I ve spent far too much time on this today already  I will leave the combination as an exercise for the dear reader

User · Answer

-    Let s cut straight to the problem  file size  Every other answer listed here bloats your minified code to the extreme  I present to you that for the best possible reduction in code size by minification  performance  readability of code  large scale project management  and syntax hinting in many code editors  this is the correct way to do enumerations  underscore-notation variables    As demonstrated in the chart above and example below  here are five easy steps to get started   Determine a name for the enumeration group  Think of a noun that can describe the purpose of the enumeration or at least the entries in the enumeration  For example  a group of enumerations representing colors choosable by the user might be better named COLORCHOICES than COLORS  Decide whether enumerations in the group are mutually-exclusive or independent  If mutually-exclusive  start each enumerated variable name with ENUM   If independent or side-by-side  use INDEX   For each entry  create a new local variable whose name starts with ENUM  or INDEX   then the name of the group  then an underscore  then a unique friendly name for the property Add a ENUMLENGTH   ENUMLEN   INDEXLENGTH   or INDEXLEN   whether LEN  or LENGTH  is personal preference  enumerated variable at the very end  You should use this variable wherever possible in your code to ensure that adding an extra entry to the enumeration and incrementing this value won t break your code  Give each successive enumerated variable a value one more than the last  starting at 0  There are comments on this page that say 0 should not be used as an enumerated value because 0    null  0    false  0        and other JS craziness  I submit to you that  to avoid this problem and boost performance at the same time  always use     and never let    appear in your code except with typeof  e x  typeof X     string    In all my years of using      I have never once had a problem with using 0 as an enumeration value  If you are still squeamish  then 1 could be used as the starting value in ENUM  enumerations  but not in INDEX  enumerations  without performance penalty in many cases   const ENUM COLORENUM RED     0  const ENUM COLORENUM GREEN   1  const ENUM COLORENUM BLUE    2  const ENUMLEN COLORENUM      3      later on  if currentColor     ENUM COLORENUM RED          whatever    Here is how I remember when to use INDEX  and when to use ENUM      Precondition  var arr          arr INDEX     ENUM    However  ENUM  can  in certain circumstances  be appropriate as an index such as when counting the occurrences of each item   x000D   x000D  const ENUM PET CAT   0        ENUM PET DOG   1        ENUM PET RAT   2        ENUMLEN PET    3   var favoritePets    ENUM PET CAT  ENUM PET DOG  ENUM PET RAT                      ENUM PET DOG  ENUM PET DOG  ENUM PET CAT                      ENUM PET RAT  ENUM PET CAT  ENUM PET DOG    var petsFrequency        for  var i 0  i lt ENUMLEN PET  i i 1 0    petsFrequency i    0   for  var i 0  len favoritePets length 0  petId 0  i lt len  i i 1 0    petsFrequency petId   favoritePets i  0     petsFrequency petId  0    1 0   console log        cat   petsFrequency ENUM PET CAT        dog   petsFrequency ENUM PET DOG        rat   petsFrequency ENUM PET RAT      x000D   x000D   x000D   Observe that  in the code above  it s really easy to add in a new kind of pet  you would just have to append a new entry after ENUM PET RAT and update ENUMLEN PET accordingly  It might be more difficult and buggy to add a new entry in other systems of enumeration        Additionally  this syntax of enumerations allows for clear and concise class extending as seen below  To extend a class  add an incrementing number to the LEN  entry of the parent class  Then  finish out the subclass with its own LEN  entry so that the subclass may be extended further in the future    x000D   x000D   function window        use strict       var parseInt   window parseInt          use INDEX  when representing the index in an array instance     const INDEX PIXELCOLOR TYPE   0     is a ENUM PIXELTYPE           INDEXLEN PIXELCOLOR     1            INDEX SOLIDCOLOR R      INDEXLEN PIXELCOLOR 0            INDEX SOLIDCOLOR G      INDEXLEN PIXELCOLOR 1            INDEX SOLIDCOLOR B      INDEXLEN PIXELCOLOR 2            INDEXLEN SOLIDCOLOR     INDEXLEN PIXELCOLOR 3            INDEX ALPHACOLOR R      INDEXLEN PIXELCOLOR 0            INDEX ALPHACOLOR G      INDEXLEN PIXELCOLOR 1            INDEX ALPHACOLOR B      INDEXLEN PIXELCOLOR 2            INDEX ALPHACOLOR A      INDEXLEN PIXELCOLOR 3            INDEXLEN ALPHACOLOR     INDEXLEN PIXELCOLOR 4         use ENUM  when representing a mutually-exclusive species or type           ENUM PIXELTYPE SOLID   0            ENUM PIXELTYPE ALPHA   1            ENUM PIXELTYPE UNKNOWN   2            ENUMLEN PIXELTYPE      2       function parseHexColor inputString            var rawstr   inputString trim   substring 1           var result               if  rawstr length     8                result INDEX PIXELCOLOR TYPE    ENUM PIXELTYPE ALPHA              result INDEX ALPHACOLOR R    parseInt rawstr substring 0 2   16               result INDEX ALPHACOLOR G    parseInt rawstr substring 2 4   16               result INDEX ALPHACOLOR B    parseInt rawstr substring 4 6   16               result INDEX ALPHACOLOR A    parseInt rawstr substring 4 6   16             else if  rawstr length     4                result INDEX PIXELCOLOR TYPE    ENUM PIXELTYPE ALPHA              result INDEX ALPHACOLOR R    parseInt rawstr 0   16    0x11              result INDEX ALPHACOLOR G    parseInt rawstr 1   16    0x11              result INDEX ALPHACOLOR B    parseInt rawstr 2   16    0x11              result INDEX ALPHACOLOR A    parseInt rawstr 3   16    0x11            else if  rawstr length     6                result INDEX PIXELCOLOR TYPE    ENUM PIXELTYPE SOLID              result INDEX SOLIDCOLOR R    parseInt rawstr substring 0 2   16               result INDEX SOLIDCOLOR G    parseInt rawstr substring 2 4   16               result INDEX SOLIDCOLOR B    parseInt rawstr substring 4 6   16             else if  rawstr length     3                result INDEX PIXELCOLOR TYPE    ENUM PIXELTYPE SOLID              result INDEX SOLIDCOLOR R    parseInt rawstr 0   16    0x11              result INDEX SOLIDCOLOR G    parseInt rawstr 1   16    0x11              result INDEX SOLIDCOLOR B    parseInt rawstr 2   16    0x11            else               result INDEX PIXELCOLOR TYPE    ENUM PIXELTYPE UNKNOWN                    return result                the red component of green     console log parseHexColor   0f0   INDEX SOLIDCOLOR R           the alpha of transparent purple     console log parseHexColor   f0f7   INDEX ALPHACOLOR A            the enumerated array for turquoise     console log parseHexColor   40E0D0        self   x000D   x000D   x000D    Length  2 450 bytes  Some may say that this is less practical than other solutions  it wastes tons of space  it takes a long time to write  and it is not coated with sugar syntax  Those people would be right if they do not minify their code  However  no reasonable person would leave unminified code in the end product  For this minification  Closure Compiler is the best I have yet to find  Online access can be found here  Closure compiler is able to take all of this enumeration data and inline it  making your Javascript be super duper small and run super duper fast  Thus  Minify with Closure Compiler  Observe       Closure compiler is able to perform some pretty incredible optimizations via inferences that are way beyond the capacities of any other Javascript minifier  Closure Compiler is able to inline primitive variables set to a fixed value  Closure Compiler is also able to make inferences based upon these inlined values and eliminate unused blocks in if-statements and loops    x000D   x000D   use strict   function e  function d a  a a trim   substring 1  var b    8   a length  b 0  1 b 1  c a substring 0 2  16  b 2  c a substring 2 4  16  b 3  c a substring 4 6  16  b 4  c a substring 4 6  16   4   a length  b 1  17 c a 0  16  b 2  17 c a 1  16  b 3  17 c a 2  16  b 4  17 c a 3  16   6   a length  b 0  0 b 1  c a substring 0 2  16  b 2  c a substring 2 4  16  b 3  c a substring 4 6  16   3   a length  b 0  0 b 1  17 c a 0  16  b 2  17 c a 1  16  b 3  17 c a 2  16   b 0  2 return b var c  e parseInt console log d   0f0   1   console log d   f0f7   4   console log d   40E0D0      self   x000D   x000D   x000D    Length  605 bytes  Closure Compiler rewards you for coding smarter and organizing your code well because  whereas many minifiers punish organized code with a bigger minified file size  Closure Compiler is able to sift through all your cleanliness and sanity to output an even smaller file size if you use tricks like variable name enumerations  That  in this one mind  is the holy grail of coding  a tool that both assists your code with a smaller minified size and assists your mind by training better programming habits      Now  let us see how big the equivalent file would be without any of these enumerations   Source Without Using Enumerations  length  1 973 bytes  477 bytes shorter than enumerated code    Minified Without Using Enumerations  length  843 bytes  238 bytes longer than enumerated code     As seen  without enumerations  the source code is shorter at the cost of a larger minified code  I do not know about you  but I know for sure that I do not incorporate source code into the end product  Thus  this form of enumerations is far superior insomuch that it results in smaller minified file sizes       Another advantage about this form of enumeration is that it can be used to easily manage large scale projects without sacrificing minified code size  When working on a large project with lots of other people  it might be beneficial to explicitly mark and label the variable names with who created the code so that the original creator of the code can be quickly identified for collaborative bug fixing     JG   Jack Giffin const ENUM JG COLORENUM RED     0        ENUM JG COLORENUM GREEN   1        ENUM JG COLORENUM BLUE    2        ENUMLEN JG COLORENUM      3      later on  if currentColor     ENUM JG COLORENUM RED          whatever       PL   Pepper Loftus    BK   Bob Knight const ENUM PL ARRAYTYPE UNSORTED     0        ENUM PL ARRAYTYPE ISSORTED     1        ENUM BK ARRAYTYPE CHUNKED      2     added by Bob Knight       ENUM JG ARRAYTYPE INCOMPLETE   3     added by jack giffin       ENUMLEN PL COLORENUM           4      later on  if    randomArray     ENUM PL ARRAYTYPE UNSORTED      randomArray     ENUM BK ARRAYTYPE CHUNKED           whatever         Further  this form of enumeration is also much faster after minification  In normal named properties  the browser has to use hashmaps to look up where the property is on the object  Although JIT compilers intelligently cache this location on the object  there is still tremendous overhead due to special cases such as deleting a lower property from the object   But  with continuous non-sparse integer-indexed PACKED ELEMENTS arrays  the browser is able to skip much of that overhead because the index of the value in the internal array is already specified  Yes  according to the ECMAScript standard  all properties are supposed to be treated as strings  Nevertheless  this aspect of the ECMAScript standard is very misleading about performance because all browsers have special optimizations for numeric indexes in arrays      Hashmaps are slow  even with JIT juice var ref       ref count   10  ref value    quot foobar quot    Compare the code above to the code below      Arrays  however  are always lightning fast const INDEX REFERENCE COUNT   0  const INDEX REFERENCE VALUE   1  const INDEXLENGTH REFERENCE   2   var ref       ref INDEX REFERENCE COUNT    10  ref INDEX REFERENCE VALUE     quot foobar quot    One might object to the code with enumerations seeming to be much longer than the code with ordinary objects  but looks can be deceiving  It is important to remember that source code size is not proportional to output size when using the epic Closure Compiler  Observe      Hashmaps are slow  even with JIT juice var a  count 10 value  quot foobar quot     The minified code without enumerations is above and the minified code with enumerations is below      Arrays  however  are always lightning fast var a  10  quot foobar quot     The example above demonstrates that  in addition to having superior performance  the enumerated code also results in a smaller minified file size     Furthermore  this one s personal cherry on the top is using this form of enumerations along with the CodeMirror text editor in Javascript mode  CodeMirror s Javascript syntax highlighting mode highlights local variables in the current scope  That way  you know instantly when you type in a variable name correctly because if the variable name was previously declared with the var keyword  then the variable name turns a special color  cyan by default   Even if you do not use CodeMirror  then at least the browser throws a helpful  variable name  is not defined exception when executing code with mistyped enumeration names  Also  JavaScript tools such as JSLint and Closure Compiler are very loud about telling you when you mistype in an enumeration variable name  CodeMirror  the browser  and various Javascript tools put together make debugging this form of enumeration very simple and really easy    x000D   x000D  const ENUM COLORENUM RED     0        ENUM COLORENUM GREEN   1        ENUM COLORENUM BLUE    2        ENUMLEN COLORENUM      3  var currentColor   ENUM COLORENUM GREEN   if currentColor     ENUM COLORENUM RED          whatever    if currentColor     ENUM COLORENUM DNE          whatever   x000D   x000D   x000D   In the above snippet  you were alerted with an error because ENUM COLORENUM DNE does not exist    I think its safe to say that this methodology of enumeration is indeed the best way to go not just for minified code size  but also for performance  debugging  and collaboration

User · Answer

Bottom line  You can t    You can fake it  but you won t get type safety  Typically this is done by creating a simple dictionary of string values mapped to integer values  For example   var DaysEnum     monday  1   tuesday  2   wednesday  3        Document Write  Enumerant      DaysEnum tuesday     The problem with this approach  You can accidentally redefine your enumerant  or accidentally have duplicate enumerant values  For example   DaysEnum monday   4     whoops  monday is now thursday  too   Edit       What about Artur Czajka s Object freeze  Wouldn t that work to prevent you from setting monday to thursday      Fry Quad    Absolutely  Object freeze would totally fix the problem I complained about  I would like to remind everyone that when I wrote the above  Object freeze didn t really exist    Now     now it opens up some very interesting possibilities    Edit 2 Here s a very good library for creating enums    http   www 2ality com 2011 10 enums html  While it probably doesn t fit every valid use of enums  it goes a very long way

User · Answer

You could also try to define a new function and therebefore a new namespace  and add variables to it  like this  function Color          Color RED   1  Color YELLOW   2   As long anybody uses the namespace granted by the function Color  everything will go fine  If you know Java  this is kind of old enums   where we use a class or interface only to hold static attributes  If a function  in javascript  is a kind of class  this is pretty much the same approach  I thing is a very simple way to define enums  Hope it helps  Greetings  Victor

User · Answer

I wrote enumerationjs a very tiny library to address the issue which ensures type safety  allow enum constants to inherit from a prototype  guaranties enum constants and enum types to be immutable   many little features  It allows to refactor a lot of code and move some logic inside the enum definition  Here is an example     var CloseEventCodes   new Enumeration  closeEventCodes       CLOSE NORMAL              id  1000  info   Connection closed normally       CLOSE GOING AWAY          id  1001  info   Connection closed going away       CLOSE PROTOCOL ERROR      id  1002  info   Connection closed due to protocol error        CLOSE UNSUPPORTED         id  1003  info   Connection closed due to unsupported operation       CLOSE NO STATUS           id  1005  info   Connection closed with no status       CLOSE ABNORMAL            id  1006  info   Connection closed abnormally       CLOSE TOO LARGE           id  1009  info   Connection closed due to too large packet        talk  function        console log this info              CloseEventCodes CLOSE TOO LARGE talk      prints  Connection closed due to too large packet  CloseEventCodes CLOSE TOO LARGE instanceof CloseEventCodes   evaluates to true   Enumeration is basically a factory    Fully documented guide available here  Hope this helps

User · Answer

If you re using Backbone  you can get full-blown enum functionality  find by id  name  custom members  for free using Backbone Collection      enum instance members  optional var Color   Backbone Model extend       print   function             console log  I am     this get  name                  enum creation var Colors   new Backbone Collection         id   1  name    Red   rgb   0xFF0000         id   2  name    Green    rgb   0x00FF00         id   3  name    Blue    rgb   0x0000FF           model   Color         Expose members through public fields  Colors each function color        Colors color get  name      color          using Colors Red print

User · Answer

What is an enum in my opinion  It s an immutable object that is always accessible and you can compare items with eachother  but the items have common properties methods  but the objects themselves or the values cannot be changed and they are instantiated only once   Enums are imho used for comparing datatypes  settings  actions to take reply things like that    So for this you need objects with the same instance so you can check if it is a enum type if something instanceof enum  Also if you get an enum object you want to be able to do stuff with it  regardless of the enum type  it should always respond in the same way   In my case its comparing values of datatypes  but it could be anything  from modifying blocks in facing direction in a 3d game to passing values on to a specific object type registry   Keeping in mind it is javascript and doesn t provide fixed enum type  you end up always making your own implementation and as this thread shows there are legions of implementations without one being the absoulte correct     This is what I use for Enums  Since enums are immutable or should be at least heh  I freeze the objects so they can t be manipulated easely   The enums can be used by EnumField STRING and they have their own methods that will work with their types  To test if something passed to an object you can use if somevar instanceof EnumFieldSegment   It may not be the most elegant solution and i m open for improvements  but this type of immutable enum unless you unfreeze it  is exactly the usecase I needed   I also realise I could have overridden the prototype with a    but my mind works better with this format  -  shoot me          simple parameter object instantiator     param name     param value     returns     function p name value        this name   name      this value   value      return Object freeze this            EnumFieldSegmentBase     function EnumFieldSegmentBase         this fieldType    STRING     function dummyregex       dummyregex prototype test   function str        if this fieldType      STRING             maxlength   arguments 1           return str length  lt   maxlength            return true      dummyregexposer   new dummyregex    EnumFieldSegmentBase prototype getInputRegex   function          switch this fieldType            case  STRING        return dummyregexposer            case  INT           return     d               case  DECIMAL2      return    d     d 1 2   d                  case  DECIMAL8      return    d     d 1 8   d                     boolean is tricky dicky  if its a boolean false  if its a string if its empty 0 or false its  false  otherwise lets see what Boolean produces         case  BOOLEAN       return dummyregexposer           EnumFieldSegmentBase prototype convertToType   function  input        var val    input      switch this fieldType            case  STRING            val    input break          case  INT           val      val 0  val   parseInt  input  break          case  DECIMAL2      if  input            input     null    input    0  if  input substr -1            input    input 0  val   new Decimal2  input  toDP 2  break          case  DECIMAL8      if  input            input     null    input    0  if  input substr -1            input    input 0  val   new Decimal8  input  toDP 8  break             boolean is tricky dicky  if its a boolean false  if its a string if its empty 0 or false its  false  otherwise lets see what Boolean produces         case  BOOLEAN       val    typeof  input     boolean     input    typeof  input      string       input      false      input            input      0     false   true    new Boolean  input  valueOf       break            return val     EnumFieldSegmentBase prototype convertToString   function  input        var val    input      switch this fieldType            case  STRING        val    input break          case  INT           val    input    break          case  DECIMAL2      val    input toPrecision   input toString   indexOf          -1    input toString   length 2    input toString   indexOf      2    break          case  DECIMAL8      val    input toPrecision   input toString   indexOf          -1    input toString   length 8    input toString   indexOf      8    break          case  BOOLEAN       val    input    true     false    break            return val     EnumFieldSegmentBase prototype compareValue   function  val1  val2        var val   false      switch this fieldType            case  STRING        val     val1    val2  break          case  INT           val     val1    val2  break          case  DECIMAL2      val     val1 comparedTo  val2    0  break          case  DECIMAL8      val     val1 comparedTo  val2    0  break          case  BOOLEAN       val     val1    val2  break            return val             EnumFieldSegment is an individual segment in the     EnumField     param  array An array consisting of object p     function EnumFieldSegment         for c 0 c lt arguments length c              if arguments c  instanceof p                this arguments c  name    arguments c  value                      return Object freeze this      EnumFieldSegment prototype   new EnumFieldSegmentBase    EnumFieldSegment prototype constructor   EnumFieldSegment           Simple enum to show what type of variable a Field type is      param STRING     param INT     param DECIMAL2     param DECIMAL8     param BOOLEAN         EnumField   Object freeze  STRING       new EnumFieldSegment new p  fieldType   STRING                                  INT         new EnumFieldSegment new p  fieldType   INT                                  DECIMAL2    new EnumFieldSegment new p  fieldType   DECIMAL2                                  DECIMAL8    new EnumFieldSegment new p  fieldType   DECIMAL8                                  BOOLEAN     new EnumFieldSegment new p  fieldType   BOOLEAN

User · Answer

In ES7   you can do an elegant ENUM relying on static attributes    class ColorEnum        static RED   0       static GREEN   1      static BLUE   2      then   if  currentColor     ColorEnum GREEN      -- coding --      The advantage   of using class instead of literal object  is to have a parent class Enum then all your Enums will extends that class      class ColorEnum  extends Enum

User · Answer

This is how Typescript translates it s enum into Javascript   var makeEnum   function obj        obj  obj  Active     1      Active       obj  obj  Closed     2      Closed       obj  obj  Deleted     3      Deleted       Now   makeEnum  NewObj             gt   1   Active   2   Closed   3   Deleted   Active  1  Closed  2  Deleted  3    At first I was confused why obj 1  returns  Active   but then realised that its dead simple - Assignment operator assigns value and then returns it   obj  foo     1      gt  1

User · Answer

You can try this      var Enum   Object freeze               Role  Object freeze   Administrator  1  Manager  2  Supervisor  3                 Color Object freeze  RED   0  GREEN   1  BLUE   2                         alert Enum Role Supervisor       alert Enum Color GREEN       var currentColor 0      if currentColor    Enum Color RED           alert  Its Red

User · Answer

I came up with this approach which is modeled after enums in Java  These are type-safe  and so you can perform instanceof checks as well   You can define enums like this   var Days   Enum define  Days     Monday    Tuesday    Wednesday    Thursday    Friday    Saturday    Sunday       Days now refers to the Days enum   Days Monday instanceof Days     true  Days Friday name        Friday  Days Friday ordinal       4  Days Sunday     Days Sunday     true Days Sunday     Days Friday     false  Days Sunday toString        Sunday   Days toString       Days   Monday  Tuesday  Wednesday  Thursday  Friday  Saturday  Sunday      Days values   map function e    return e name            Monday    Tuesday    Wednesday    Thursday    Friday    Saturday    Sunday   Days values   4  name       Friday   Days fromName  Thursday       Days Thursday    true Days fromName  Wednesday   name       Wednesday  Days Friday fromName  Saturday   name       Saturday    The implementation   var Enum    function                     Function to define an enum         param typeName - The name of the enum          param constants - The constants on the enum  Can be an array of strings  or an object where each key is an enum        constant  and the values are objects that describe attributes that can be attached to the associated constant              function define typeName  constants                 Check Arguments             if  typeof typeName      undefined                 throw new TypeError  A name is required                        if    constants instanceof Array   amp  amp   Object getPrototypeOf constants      Object prototype                  throw new TypeError  The constants parameter must either be an array or an object                else if   constants instanceof Array   amp  amp  constants length     0                 throw new TypeError  Need to provide at least one constant                else if   constants instanceof Array   amp  amp   constants reduce function  isString  element                    return isString  amp  amp   typeof element      string                   true                  throw new TypeError  One or more elements in the constant array is not a string                else if  Object getPrototypeOf constants      Object prototype  amp  amp   Object keys constants  reduce function  isObject  constant                    return Object getPrototypeOf constants constant       Object prototype                 true                  throw new TypeError  One or more constants do not have an associated object-value                         var isArray    constants instanceof Array           var isObject    isArray               Private sentinel-object used to guard enum constructor so that no one else can create enum instances             function                        Dynamically define a function with the same name as the enum we want to define              var   enum   new Function                      return function     typeName     sentinel  name  ordinal                        if   sentinel instanceof                                throw new TypeError   Cannot instantiate an instance of     typeName                                                     this   name   name                      this   ordinal   ordinal                                                 Private objects used to maintain enum instances for values    and to look up enum instances for fromName               var   values               var   dict                    Attach values   and fromName   methods to the class itself  kind of like static methods               Object defineProperty   enum   values                 value  function                      return   values                                     Object defineProperty   enum   fromName                 value  function  name                    var   constant     dict name                  if    constant                        return   constant                    else                       throw new TypeError typeName     does not have a constant with name     name                                                                             The following methods are available to all instances of the enum  values   and fromName   need to be            available to each constant  and so we will attach them on the prototype  But really  they re just            aliases to their counterparts on the prototype                      Object defineProperty   enum prototype   values                 value    enum values                      Object defineProperty   enum prototype   fromName                 value    enum fromName                      Object defineProperty   enum prototype   name                 value  function                      return this   name                                     Object defineProperty   enum prototype   ordinal                 value  function                      return this   ordinal                                     Object defineProperty   enum prototype   valueOf                 value  function                      return this   name                                     Object defineProperty   enum prototype   toString                 value  function                      return this   name                                                    If constants was an array  we can the element values directly  Otherwise  we will have to use the keys            from the constants object                      var  constants   constants          if  isObject                 constants   Object keys constants                          Iterate over all constants  create an instance of our enum for each one  and attach it to the enum type              constants forEach function  name  ordinal                   Create an instance of the enum             var   constant   new   enum new       name  ordinal                   If constants was an object  we want to attach the provided attributes to the instance              if  isObject                    Object keys constants name   forEach function  attr                        Object defineProperty   constant  attr                            value  constants name  attr                                                                            Freeze the instance so that it cannot be modified              Object freeze   constant                   Attach the instance using the provided name to the enum type itself              Object defineProperty   enum  name                    value    constant                                 Update our private objects               values push   constant                 dict name      constant                           Define a friendly toString method for the enum             var string   typeName             enum values   map function  c                    return c name                   join                         Object defineProperty   enum   toString                 value  function                      return string                                         Freeze our private objects             Object freeze   values           Object freeze   dict                Freeze the prototype on the enum and the enum itself             Object freeze   enum prototype           Object freeze   enum                Return the enum             return   enum             return           define  define

User · Answer

Even though only static methods  and not static properties  are supported in ES2015  see here as well   sect 15 2 2 2   curiously you can use the below with Babel with the es2015 preset   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 lt CellState gt            const rv               rv push CellState EMPTY           rv push CellState OCCUPIED           rv push CellState HIGHLIGHTED           return rv          Object freeze CellState     I found this to be working as expected even across modules  e g  importing the CellState enum from another module  and also when I import a module using Webpack   The advantage this method has over most other answers is that you can use it alongside a static type checker  e g  Flow  and you can assert  at development time using static type checking  that your variables  parameters  etc  are of the specific CellState  enum  rather than some other enum  which would be impossible to distinguish if you used generic objects or symbols    update  The above code has a deficiency in that it allows one to create additional objects of type CellState  even though one can t assign them to the static fields of CellState since it s frozen   Still  the below more refined code offers the following advantages    no more objects of type CellState may be created you are guaranteed that no two enum instances are assigned the same code utility method to get the enum back from a string representation the values function that returns all instances of the enum does not have to create the return value in the above  manual  and error-prone  way    use strict    class Status    constructor code  displayName   code        if  Status INSTANCES has code           throw new Error  duplicate code value     code          if   Status canCreateMoreInstances          throw new Error  attempt to call constructor   code                displayName   after all static instances have been created        this code          code      this displayName   displayName      Object freeze this       Status INSTANCES set this code  this      toString         return   code    this code   displayName    this displayName       static INSTANCES     new Map    static canCreateMoreInstances        true      the values  static ARCHIVED      new Status  Archived    static OBSERVED      new Status  Observed    static SCHEDULED     new Status  Scheduled    static UNOBSERVED    new Status  Unobserved    static UNTRIGGERED   new Status  Untriggered     static values        function         return Array from Status INSTANCES values        static fromCode code        if   Status INSTANCES has code           throw new Error  unknown code    code         else         return Status INSTANCES get code        Status canCreateMoreInstances   false  Object freeze Status   exports Status   Status

User · Answer

This is an old one I know  but the way it has since been implemented via the TypeScript interface is   var MyEnum   function  MyEnum        MyEnum MyEnum  Foo     0     Foo       MyEnum MyEnum  FooBar     2     FooBar       MyEnum MyEnum  Bar     1     Bar      MyEnum    MyEnum          This enables you to look up on both MyEnum Bar which returns 1  and MyEnum 1  which returns  Bar  regardless of the order of declaration

User · Answer

I ve made an Enum class that can fetch values AND names at O 1   It can also generate an Object Array containing all Names and Values   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      lt option value      this k       gt     k     lt  option gt                              this  reserved  selectOptionsHTML   html                    return this  reserved  selectOptionsHTML            call Enum prototype     You can init d it like this   var enum1   new Enum       item1  0      item2  1      item3  2       To fetch a value  like Enums in C     var val2   enum1 item2    To fetch a name for a value  can be ambiguous when putting the same value for different names    var name1   enum1 GetName 0        item1    To get an array with each name  amp  value in an object   var arr   enum1 GetObjArr      Will generate      Name   item1   Value  0                    You can also get the html select options readily   var html   enum1 GetSelectOptionsHTML      Which holds     lt option value  0  gt item1 lt  option gt

User · Answer

If you re using Backbone  you can get full-blown enum functionality  find by id  name  custom members  for free using Backbone Collection      enum instance members  optional var Color   Backbone Model extend       print   function             console log  I am     this get  name                  enum creation var Colors   new Backbone Collection         id   1  name    Red   rgb   0xFF0000         id   2  name    Green    rgb   0x00FF00         id   3  name    Blue    rgb   0x0000FF           model   Color         Expose members through public fields  Colors each function color        Colors color get  name      color          using Colors Red print

User · Answer

This is the solution that I use   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  lt  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  gt   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      And you define your enums like this   var COLORS   defineEnum       RED             value   1          string    red             GREEN             value   2          string    green             BLUE             value   3          string    blue              And this is how you access your enums   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       I usually use the last 2 methods for mapping enums from message objects   Some advantages to this approach    Easy to declare enums Easy to access your enums Your enums can be complex types The Enum class has some associative caching if you are using getByValue a lot   Some disadvantages    Some messy memory management going on in there  as I keep the references to the enums Still no type safety

User · Answer

Even though only static methods  and not static properties  are supported in ES2015  see here as well   sect 15 2 2 2   curiously you can use the below with Babel with the es2015 preset   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 lt CellState gt            const rv               rv push CellState EMPTY           rv push CellState OCCUPIED           rv push CellState HIGHLIGHTED           return rv          Object freeze CellState     I found this to be working as expected even across modules  e g  importing the CellState enum from another module  and also when I import a module using Webpack   The advantage this method has over most other answers is that you can use it alongside a static type checker  e g  Flow  and you can assert  at development time using static type checking  that your variables  parameters  etc  are of the specific CellState  enum  rather than some other enum  which would be impossible to distinguish if you used generic objects or symbols    update  The above code has a deficiency in that it allows one to create additional objects of type CellState  even though one can t assign them to the static fields of CellState since it s frozen   Still  the below more refined code offers the following advantages    no more objects of type CellState may be created you are guaranteed that no two enum instances are assigned the same code utility method to get the enum back from a string representation the values function that returns all instances of the enum does not have to create the return value in the above  manual  and error-prone  way    use strict    class Status    constructor code  displayName   code        if  Status INSTANCES has code           throw new Error  duplicate code value     code          if   Status canCreateMoreInstances          throw new Error  attempt to call constructor   code                displayName   after all static instances have been created        this code          code      this displayName   displayName      Object freeze this       Status INSTANCES set this code  this      toString         return   code    this code   displayName    this displayName       static INSTANCES     new Map    static canCreateMoreInstances        true      the values  static ARCHIVED      new Status  Archived    static OBSERVED      new Status  Observed    static SCHEDULED     new Status  Scheduled    static UNOBSERVED    new Status  Unobserved    static UNTRIGGERED   new Status  Untriggered     static values        function         return Array from Status INSTANCES values        static fromCode code        if   Status INSTANCES has code           throw new Error  unknown code    code         else         return Status INSTANCES get code        Status canCreateMoreInstances   false  Object freeze Status   exports Status   Status

User · Answer

Read all the answers and didn t found any non-verbose and DRY solution  I use this one-liner   const modes     DRAW    SCALE    DRAG   reduce  o  v    gt        o   v   v            it generates an object with human-readable values       DRAW   DRAW     SCALE   SCALE     DRAG   DRAG

User · Answer

There are basically two types of enums  global  like C  and object-like  like TypeScript   For global enums  do something like this-    Note that    enum is optional  though it makes it look slightly better  const    enum   SUNDAY   1    MONDAY   2    TUESDAY   3    WEDNSDAY   4    THURSDAY   5    FRIDAY   6    SATURDAY   7   And for object-like enums  do this  like Artur Czajka s answer -    A trailing comma isn t required but is a good habit  const Days   Object freeze     SUNDAY   1    MONDAY   2    TUESDAY   3    WEDSNDAY   4    THURSDAY   5    FRIDAY   6    SATURDAY   7       or const Days       SUNDAY   1    MONDAY   2    TUESDAY   3    WEDSNDAY   4    THURSDAY   5    FRIDAY   6    SATURDAY   7     Object freeze Days    The first way to declare object-like enums looks slightly cleaner  By the way  global and object-like enums aren t really correct terms  I made them up  Edit  A solution made  for global enums  by Aral Roca  it looks amazing but has a con of being slow  like 0 1 seconds slow - function  ENUM count   1      while  true  yield count       and then const   RED  GREEN  BLUE     ENUM

User · Answer

You can use Object prototype hasOwnProperty      x000D   x000D  var findInEnum  x000D      colorEnum     x000D      red   0  x000D      green   1  x000D      blue   2 x000D     x000D   x000D     later on x000D   x000D  findInEnum   function  enumKey    x000D    if  colorEnum hasOwnProperty enumKey     x000D      return enumKey   Value      colorEnum enumKey  x000D      x000D    x000D   x000D  alert findInEnum  blue    x000D   x000D   x000D

User · Answer

UPDATE  Thanks for all the upvotes everyone  but I don t think my answer below is the best way to write enums in JavaScript anymore  See my blog post for more details  Enums in JavaScript     Alerting the name is already possible   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            Alternatively  you could make the values objects  so you can have the cake and eat it too   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       In JavaScript  as it is a dynamic language  it is even possible to add enum values to the set later      Add EXTRALARGE size SIZE EXTRALARGE    value  3  name   Extra Large   code   XL      Remember  the fields of the enum  value  name and code in this example  are not needed for the identity check and are only there for convenience  Also the name of the size property itself does not need to be hard coded  but can also be set dynamically  So supposing you only know the name for your new enum value  you can still add it without problems      Add  Extra Large  size  only knowing it s name var name    Extra Large   SIZE name     value  -1  name  name  code          Of course this means that some assumptions can no longer be made  that value represents the correct order for the size for example     Remember  in JavaScript an object is just like a map or hash table  A set of name-value pairs  You can loop through them or otherwise manipulate them without knowing much about them in advance   Example  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                   And by the way  if you are interested in namespaces  you may want to have a look at my solution for simple but powerful namespace and dependency management for JavaScript  Packages JS

User · Answer

What is an enum in my opinion  It s an immutable object that is always accessible and you can compare items with eachother  but the items have common properties methods  but the objects themselves or the values cannot be changed and they are instantiated only once   Enums are imho used for comparing datatypes  settings  actions to take reply things like that    So for this you need objects with the same instance so you can check if it is a enum type if something instanceof enum  Also if you get an enum object you want to be able to do stuff with it  regardless of the enum type  it should always respond in the same way   In my case its comparing values of datatypes  but it could be anything  from modifying blocks in facing direction in a 3d game to passing values on to a specific object type registry   Keeping in mind it is javascript and doesn t provide fixed enum type  you end up always making your own implementation and as this thread shows there are legions of implementations without one being the absoulte correct     This is what I use for Enums  Since enums are immutable or should be at least heh  I freeze the objects so they can t be manipulated easely   The enums can be used by EnumField STRING and they have their own methods that will work with their types  To test if something passed to an object you can use if somevar instanceof EnumFieldSegment   It may not be the most elegant solution and i m open for improvements  but this type of immutable enum unless you unfreeze it  is exactly the usecase I needed   I also realise I could have overridden the prototype with a    but my mind works better with this format  -  shoot me          simple parameter object instantiator     param name     param value     returns     function p name value        this name   name      this value   value      return Object freeze this            EnumFieldSegmentBase     function EnumFieldSegmentBase         this fieldType    STRING     function dummyregex       dummyregex prototype test   function str        if this fieldType      STRING             maxlength   arguments 1           return str length  lt   maxlength            return true      dummyregexposer   new dummyregex    EnumFieldSegmentBase prototype getInputRegex   function          switch this fieldType            case  STRING        return dummyregexposer            case  INT           return     d               case  DECIMAL2      return    d     d 1 2   d                  case  DECIMAL8      return    d     d 1 8   d                     boolean is tricky dicky  if its a boolean false  if its a string if its empty 0 or false its  false  otherwise lets see what Boolean produces         case  BOOLEAN       return dummyregexposer           EnumFieldSegmentBase prototype convertToType   function  input        var val    input      switch this fieldType            case  STRING            val    input break          case  INT           val      val 0  val   parseInt  input  break          case  DECIMAL2      if  input            input     null    input    0  if  input substr -1            input    input 0  val   new Decimal2  input  toDP 2  break          case  DECIMAL8      if  input            input     null    input    0  if  input substr -1            input    input 0  val   new Decimal8  input  toDP 8  break             boolean is tricky dicky  if its a boolean false  if its a string if its empty 0 or false its  false  otherwise lets see what Boolean produces         case  BOOLEAN       val    typeof  input     boolean     input    typeof  input      string       input      false      input            input      0     false   true    new Boolean  input  valueOf       break            return val     EnumFieldSegmentBase prototype convertToString   function  input        var val    input      switch this fieldType            case  STRING        val    input break          case  INT           val    input    break          case  DECIMAL2      val    input toPrecision   input toString   indexOf          -1    input toString   length 2    input toString   indexOf      2    break          case  DECIMAL8      val    input toPrecision   input toString   indexOf          -1    input toString   length 8    input toString   indexOf      8    break          case  BOOLEAN       val    input    true     false    break            return val     EnumFieldSegmentBase prototype compareValue   function  val1  val2        var val   false      switch this fieldType            case  STRING        val     val1    val2  break          case  INT           val     val1    val2  break          case  DECIMAL2      val     val1 comparedTo  val2    0  break          case  DECIMAL8      val     val1 comparedTo  val2    0  break          case  BOOLEAN       val     val1    val2  break            return val             EnumFieldSegment is an individual segment in the     EnumField     param  array An array consisting of object p     function EnumFieldSegment         for c 0 c lt arguments length c              if arguments c  instanceof p                this arguments c  name    arguments c  value                      return Object freeze this      EnumFieldSegment prototype   new EnumFieldSegmentBase    EnumFieldSegment prototype constructor   EnumFieldSegment           Simple enum to show what type of variable a Field type is      param STRING     param INT     param DECIMAL2     param DECIMAL8     param BOOLEAN         EnumField   Object freeze  STRING       new EnumFieldSegment new p  fieldType   STRING                                  INT         new EnumFieldSegment new p  fieldType   INT                                  DECIMAL2    new EnumFieldSegment new p  fieldType   DECIMAL2                                  DECIMAL8    new EnumFieldSegment new p  fieldType   DECIMAL8                                  BOOLEAN     new EnumFieldSegment new p  fieldType   BOOLEAN

User · Answer

This answer is an alternative approach for specific circumstances   I needed a set of bitmask constants based on attribute sub-values  cases where an attribute value is an array or list of values   It encompasses the equivalent of several overlapping enums    I created a class to both store and generate the bitmask values  I can then use the pseudo-constant bitmask values this way to test  for example  if green is present in an RGB value    if  value  amp  Ez G          In my code I create only one instance of this class   There doesn t seem to be a clean way to do this without instantiating at least one instance of the class  Here is the class declaration and bitmask value generation code   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  lt  a length  i    j    2              this a i     j           The 2D array is for the SVG feColorMatrix values attribute  which is a 4x5 matrix of RGBA by RGBAM  where M is a multiplier  The resulting Ez properties are Ez RR  Ez RG  etc

User · Answer

This is how Typescript translates it s enum into Javascript   var makeEnum   function obj        obj  obj  Active     1      Active       obj  obj  Closed     2      Closed       obj  obj  Deleted     3      Deleted       Now   makeEnum  NewObj             gt   1   Active   2   Closed   3   Deleted   Active  1  Closed  2  Deleted  3    At first I was confused why obj 1  returns  Active   but then realised that its dead simple - Assignment operator assigns value and then returns it   obj  foo     1      gt  1

User · Answer

Since 1 8 5 it s possible to seal and freeze the object  so define the above as  const DaysEnum   Object freeze   quot monday quot  1   quot tuesday quot  2   quot wednesday quot  3         or const DaysEnum     quot monday quot  1   quot tuesday quot  2   quot wednesday quot  3       Object freeze DaysEnum   and voila  JS enums  However  this doesn t prevent you from assigning an undesired value to a variable  which is often the main goal of enums  let day   DaysEnum tuesday day   298832342    goes through without any errors  One way to ensure a stronger degree of type safety  with enums or otherwise  is to use a tool like TypeScript or Flow  Quotes aren t needed but I kept them for consistency

User · Answer

I ve made an Enum class that can fetch values AND names at O 1   It can also generate an Object Array containing all Names and Values   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      lt option value      this k       gt     k     lt  option gt                              this  reserved  selectOptionsHTML   html                    return this  reserved  selectOptionsHTML            call Enum prototype     You can init d it like this   var enum1   new Enum       item1  0      item2  1      item3  2       To fetch a value  like Enums in C     var val2   enum1 item2    To fetch a name for a value  can be ambiguous when putting the same value for different names    var name1   enum1 GetName 0        item1    To get an array with each name  amp  value in an object   var arr   enum1 GetObjArr      Will generate      Name   item1   Value  0                    You can also get the html select options readily   var html   enum1 GetSelectOptionsHTML      Which holds     lt option value  0  gt item1 lt  option gt

User · Answer

IE8 does Not support freeze   method  Source  http   kangax github io compat-table es5   Click on  Show obsolete browsers   on top  and check IE8  amp  freeze row col intersection   In my current game project  I have used below  since few customers still use IE8   var CONST WILD TYPES         REGULAR   REGULAR       EXPANDING   EXPANDING       STICKY   STICKY       SHIFTING   SHIFTING       We could also do     var CONST WILD TYPES         REGULAR   RE       EXPANDING   EX       STICKY   ST       SHIFTING   SH       or even this     var CONST WILD TYPES         REGULAR   1       EXPANDING   2       STICKY   3       SHIFTING   4       The last one  seems most efficient for string  it reduces your total bandwidth if you have server  amp  client exchanging this data  Of course  now it s your duty to make sure there are no conflicts in the data  RE  EX  etc  must be unique  also 1  2  etc  should be unique   Note that you need to maintain these forever for backward compatibility     Assignment   var wildType   CONST WILD TYPES REGULAR    Comparision   if  wildType     CONST WILD TYPES REGULAR           do something here

User · Answer

var DaysEnum   Object freeze    monday      tuesday                You don t need to specify an id  you can just use an empty object to compare enums    if  incommingEnum     DaysEnum monday    incommingEnum is monday   EDIT  If you are going to serialize the object  to JSON for instance  you ll the id again      taken from Gabriel Llamas comment     edit based on Stijn de Witt s comment

User · Answer

I ve just published an NPM package gen enum allows you to create Enum data structure in Javascript quickly   var genEnum   require  gen enum     var AppMode   genEnum  SIGN UP  LOG IN  FORGOT PASSWORD    var curMode   AppMode LOG IN  console log curMode isLogIn        output true  console log curMode isSignUp        output false  console log curMode isForgotPassword        output false    One nice thing about this little tool is in modern environment  including nodejs and IE 9  browsers  the returned Enum object is immutable   For more information please checkout https   github com greenlaw110 enumjs  Updates  I obsolete gen enum package and merge the function into constjs package  which provides more features including immutable objects  JSON string deserialization  string constants and bitmap generation etc  Checkout https   www npmjs com package constjs for more information   To upgrade from gen enum to constjs just change the statement  var genEnum   require  gen enum      to  var genEnum   require  constjs   enum

User · Answer

Here s my take on a  flagged  Enum factory  Here s a working demo        Notes      The proxy handler enables case insensitive property queries    BigInt is used to enable bitflag strings  w length  gt  52    function EnumFactory       const proxyfy         construct target  args           const caseInsensitiveHandler                get target  key              return target key toUpperCase       target key                               const proxified   new Proxy new target    args   caseInsensitiveHandler           return Object freeze proxified                const ProxiedEnumCtor   new Proxy EnumCtor  proxyfy     const throwIf           assertion   false         message    Unspecified error          ErrorType   Error     gt         assertion  amp  amp        gt    throw new ErrorType message           const hasFlag    val  sub    gt        throwIf  val     sub   quot valueIn  missing parameters quot   RangeError       const andVal    sub  amp  val       return andVal     BigInt 0   amp  amp  andVal     val          function EnumCtor values        throwIf values constructor     Array                 values length  lt  2             values filter  v   gt  v constructor     String   length  gt  0         EnumFactory  expected Array of at least 2 strings   TypeError       const base   BigInt 1       this NONE   BigInt 0       values forEach   v  i    gt  this v toUpperCase      base lt  lt BigInt i            EnumCtor prototype         get keys     return Object keys this  slice 1          subset sub          const arrayValues   this keys        return new ProxiedEnumCtor              sub toString 2   reverse              reduce   acc  v  i    gt     v  lt  1   acc       acc  arrayValues i                               getLabel enumValue          const tryLabel   Object entries this  find  value   gt  value 1      enumValue          return  enumValue     tryLabel length             quot getLabel  no value parameter or value not in enum quot            tryLabel shift               hasFlag val  sub   this    return hasFlag val  sub                return arr   gt  new ProxiedEnumCtor arr

User · Answer

As of writing  October 2014 - so here is a contemporary solution  Am writing the solution as a Node Module  and have included a test using Mocha and Chai  as well as underscoreJS  You can easily ignore these  and just take the Enum code if preferred   Seen a lot of posts with overly convoluted libraries etc  The solution to getting enum support in Javascript is so simple it really isn t needed  Here is the code   File  enums js      require  underscore     var  Enum   function          var keys     map arguments  function  value          return value            var self           keys  keys          for  var i   0  i  lt  arguments length  i            self keys i     i          return self      var fileFormatEnum   Object freeze  Enum  CSV    TSV     var encodingEnum   Object freeze  Enum  UTF8    SHIFT JIS      exports fileFormatEnum   fileFormatEnum  exports encodingEnum   encodingEnum    And a test to illustrate what it gives you   file  enumsSpec js  var chai   require  chai        assert   chai assert      expect   chai expect      should   chai should        enums   require    enums            require  underscore      describe  enums   function           describe  fileFormatEnum   function              it  should return expected fileFormat enum declarations   function                  var fileFormatEnum   enums fileFormatEnum              should exist fileFormatEnum               assert    keys    CSV   TSV    CSV  0  TSV  1       JSON stringify fileFormatEnum    Unexpected format                assert    CSV   TSV        JSON stringify fileFormatEnum keys    Unexpected keys format                             describe  encodingEnum   function              it  should return expected encoding enum declarations   function                  var encodingEnum   enums encodingEnum              should exist encodingEnum               assert    keys    UTF8   SHIFT JIS    UTF8  0  SHIFT JIS  1       JSON stringify encodingEnum    Unexpected format                assert    UTF8   SHIFT JIS        JSON stringify encodingEnum keys    Unexpected keys format                               As you can see  you get an Enum factory  you can get all the keys simply by calling enum keys  and you can match the keys themselves to integer constants  And you can reuse the factory with different values  and export those generated Enums using Node s modular approach    Once again  if you are just a casual user  or in the browser etc  just take the factory part of the code  potentially removing underscore library too if you don t wish to use it in your code

User · Answer

You could try using https   bitbucket org snippets frostbane aAjxM   my namespace ColorEnum   new Enum       RED   0        GREEN        BLUE      It should work up to ie8

User · Answer

This can be useful  const  CATS  DOGS  BIRDS    ENUM     The implementation is simple and efficient  function   ENUM count 1    while true  yield count      A generator can yield the exact sequence of integers required  without knowing how many constants there are  It can also support an optional argument that specifies which  possibly negative  number to start from  defaulting to 1

User · Answer

You can do something like this      var Enum    function foo         var EnumItem   function item           if typeof item     string                this name   item            else               this name   item name                      EnumItem prototype   new String  DEFAULT        EnumItem prototype toString   function            return this name            EnumItem prototype equals   function item           if typeof item     string                return this name    item            else               return this    item  amp  amp  this name    item name                       function Enum             this add apply this  arguments           Object freeze this             Enum prototype add   function             for  var i in arguments                var enumItem   new EnumItem arguments i                this enumItem name    enumItem                       Enum prototype toList   function             return Object keys this              foo Enum   Enum      return Enum     this   var STATUS   new Enum  CLOSED   PENDING     name    CONFIRMED   ackd   true     var STATE   new Enum  CLOSED   PENDING   CONFIRMED    name    STARTED     name    PROCESSING       As defined in this library  https   github com webmodule foo blob master foo js L217  Complete example https   gist github com lnt bb13a2fd63cdb8bce85fd62965a20026

User · Answer

You can use a simple funcion to invert keys and values  it will work with arrays also as it converts numerical integer strings to numbers  The code is small  simple and reusable for this and other use cases    x000D   x000D  var objInvert   function  obj    x000D      var invert      x000D      for  var i in obj    x000D        if  i match    d      i   parseInt i 10  x000D        invert obj i     i x000D        x000D      return invert x000D    x000D    x000D  var musicStyles   Object freeze objInvert   ROCK    SURF    METAL   x000D   BOSSA-NOVA   POP   INDIE     x000D   x000D  console log musicStyles  x000D   x000D   x000D

User · Answer

I had done it a while ago using a mixture of   defineGetter   and   defineSetter   or defineProperty depending on the JS version   Here s the enum generating function I made  https   gist github com gfarrell 6716853  You d use it like this   var Colours   Enum  RED    GREEN    BLUE      And it would create an immutable string int dictionary  an enum

User · Answer

I ve modified the solution of 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               Test   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

User · Answer

This answer is an alternative approach for specific circumstances   I needed a set of bitmask constants based on attribute sub-values  cases where an attribute value is an array or list of values   It encompasses the equivalent of several overlapping enums    I created a class to both store and generate the bitmask values  I can then use the pseudo-constant bitmask values this way to test  for example  if green is present in an RGB value    if  value  amp  Ez G          In my code I create only one instance of this class   There doesn t seem to be a clean way to do this without instantiating at least one instance of the class  Here is the class declaration and bitmask value generation code   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  lt  a length  i    j    2              this a i     j           The 2D array is for the SVG feColorMatrix values attribute  which is a 4x5 matrix of RGBA by RGBAM  where M is a multiplier  The resulting Ez properties are Ez RR  Ez RG  etc

User · Answer

var ColorEnum         red          green          blue         You don t need to make sure you don t assign duplicate numbers to different enum values this way  A new object gets instantiated and assigned to all enum values

User · Answer

class Enum     constructor     vals        vals forEach  val   gt          const CONSTANT   Symbol val         Object defineProperty this  val toUpperCase              get                return CONSTANT                     set  val              const enum val    CONSTANT                generate TypeError associated with attempting to change the value of a constant           enum val   val                                      Example of usage   const COLORS   new Enum  red    blue    green

User · Answer

It s easy to use  I think  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     UPDATE   There is my helper codes TypeHelper     x000D   x000D  var Helper     x000D      isEmpty  function  obj    x000D          return  obj    obj     null    obj     undefined    Array isArray obj   amp  amp  obj length     0  x000D         x000D   x000D      isObject  function  obj    x000D          return  typeof obj      object    x000D         x000D   x000D      sortObjectKeys  function  object    x000D          return Object keys object  x000D               sort function  a  b    x000D                  c   a - b  x000D                  return c x000D                  x000D         x000D      containsItem  function  arr  item    x000D          if  arr  amp  amp  Array isArray arr     x000D              return arr indexOf item   gt  -1  x000D            else   x000D              return arr     item  x000D            x000D         x000D   x000D      pushArray  function  arr1  arr2    x000D          if  arr1  amp  amp  arr2  amp  amp  Array isArray arr1     x000D              arr1 push apply arr1  Array isArray arr2    arr2    arr2    x000D            x000D        x000D     x000D  function TypeHelper     x000D      var  types   arguments 0   x000D           defTypeIndex   0  x000D           currentType  x000D           value  x000D           allKeys   Helper sortObjectKeys  types   x000D   x000D      if  arguments length    2    x000D           defTypeIndex   arguments 1   x000D        x000D   x000D      Object defineProperties this    x000D          Key    x000D              get  function      x000D                  return  currentType  x000D                 x000D              set  function  val    x000D                   currentType setType val  true   x000D                 x000D              enumerable  true x000D             x000D          Value    x000D              get  function      x000D                  return  types  currentType   x000D                 x000D              set  function  val    x000D                   value setType val  false   x000D                 x000D              enumerable  true x000D            x000D          x000D      this getAsList   function  keys    x000D          var list       x000D           allKeys forEach function  key  idx  array    x000D              if  key  amp  amp   types key     x000D   x000D                  if   Helper isEmpty keys   amp  amp  Helper containsItem keys  key     Helper isEmpty keys     x000D                      var json       x000D                      json Key   key  x000D                      json Value    types key   x000D                      Helper pushArray list  json   x000D                    x000D                x000D              x000D          return list  x000D         x000D   x000D      this setType   function  value  isKey    x000D          if   Helper isEmpty value     x000D              Object keys  types  forEach function  key  idx  array    x000D                  if  Helper isObject value     x000D                      if  value  amp  amp  value Key    key    x000D                           currentType   key  x000D                        x000D                    else if  isKey    x000D                      if  value  amp  amp  value toString      key toString      x000D                           currentType   key  x000D                        x000D                    else if  value  amp  amp  value toString       types key     x000D                       currentType   key  x000D                    x000D                  x000D            else   x000D              this setDefaultType    x000D            x000D          return isKey    types  currentType     currentType  x000D         x000D   x000D      this setTypeByIndex   function  index    x000D          for  var i   0  i  lt   allKeys length  i      x000D              if  index     i    x000D                   currentType    allKeys index   x000D                  break  x000D                x000D            x000D         x000D   x000D      this setDefaultType   function      x000D          this setTypeByIndex  defTypeIndex   x000D         x000D   x000D      this setDefaultType    x000D    x000D   x000D  var TypeA     x000D       -1    Any   x000D       2    2L   x000D       100    100L   x000D       200    200L   x000D       1000    1000L  x000D     x000D   x000D  var enumA   new TypeHelper TypeA  4   x000D   x000D  document writeln  Key      enumA Key    Value      enumA Value    lt br gt     x000D   x000D   x000D  enumA setType  200L   false   x000D  document writeln  Key      enumA Key    Value      enumA Value    lt br gt     x000D   x000D  enumA setDefaultType    x000D  document writeln  Key      enumA Key    Value      enumA Value    lt br gt     x000D   x000D   x000D  enumA setTypeByIndex 1   x000D  document writeln  Key      enumA Key    Value      enumA Value    lt br gt     x000D   x000D  document writeln  is equals       enumA Value    TypeA  2      x000D   x000D   x000D

User · Answer

The com recoyxgroup javascript enum package allows you to properly define enum and flags enum classes  where   Every constant is represented as an immutable    value  someNumber   Every constant has a property attached to the enum class  E CONSTANT NAME  Every constant has a friendly String  constantName  Every constant has a Number  someNumber  You can declare custom properties methods using E prototype   Wherever a specific enum is expected  the convention is to do E v   like this  const   FlagsEnum   from  com recoyxgroup javascript enum    const Rights   FlagsEnum  Rights          ADMINISTRATION        REVIEW        function fn rights        rights   Rights rights       console log  administration  in rights   review  in rights      fn    administration    review         true true fn   administration        true false fn  undefined       false false  var r   Rights ADMINISTRATION  console log  r     administration      As you can see  you can still compare the value to a String  Definitions can be more specific  const E   FlagsEnum  E           Q   0x10         K    someB          L    0x40   someL          FlagsEnum products  gt  Instance properties methods  number  was going to be valueOf    but because of JS     had to be  number   set   exclude   toggle   filter   valueOf   toString

User · Answer

Here s what we all want   function Enum constantsList        for  var i in constantsList            this constantsList i     i            Now you can create your enums   var YesNo   new Enum   NO    YES     var Color   new Enum   RED    GREEN    BLUE       By doing this  constants can be acessed in the usual way  YesNo YES  Color GREEN  and they get a sequential int value  NO   0  YES   1  RED   0  GREEN   1  BLUE   2    You can also add methods  by using Enum prototype   Enum prototype values   function         return this allValues         for the above to work  you d need to do             this allValues   constantsList at the constructor          Edit - small improvement - now with varargs   unfortunately it doesn t work properly on IE  S    should stick with previous version then   function Enum         for  var i in arguments            this arguments i     i           var YesNo   new Enum  NO    YES    var Color   new Enum  RED    GREEN    BLUE

User · Answer

This isn t much of an answer  but I d say that works just fine  personally  Having said that  since it doesn t matter what the values are  you ve used 0  1  2   I d use a meaningful string in case you ever wanted to output the current value

User · Answer

Bottom line  You can t    You can fake it  but you won t get type safety  Typically this is done by creating a simple dictionary of string values mapped to integer values  For example   var DaysEnum     monday  1   tuesday  2   wednesday  3        Document Write  Enumerant      DaysEnum tuesday     The problem with this approach  You can accidentally redefine your enumerant  or accidentally have duplicate enumerant values  For example   DaysEnum monday   4     whoops  monday is now thursday  too   Edit       What about Artur Czajka s Object freeze  Wouldn t that work to prevent you from setting monday to thursday      Fry Quad    Absolutely  Object freeze would totally fix the problem I complained about  I would like to remind everyone that when I wrote the above  Object freeze didn t really exist    Now     now it opens up some very interesting possibilities    Edit 2 Here s a very good library for creating enums    http   www 2ality com 2011 10 enums html  While it probably doesn t fit every valid use of enums  it goes a very long way

User · Answer

You can use a simple funcion to invert keys and values  it will work with arrays also as it converts numerical integer strings to numbers  The code is small  simple and reusable for this and other use cases    x000D   x000D  var objInvert   function  obj    x000D      var invert      x000D      for  var i in obj    x000D        if  i match    d      i   parseInt i 10  x000D        invert obj i     i x000D        x000D      return invert x000D    x000D    x000D  var musicStyles   Object freeze objInvert   ROCK    SURF    METAL   x000D   BOSSA-NOVA   POP   INDIE     x000D   x000D  console log musicStyles  x000D   x000D   x000D

User · Answer

-    Let s cut straight to the problem  file size  Every other answer listed here bloats your minified code to the extreme  I present to you that for the best possible reduction in code size by minification  performance  readability of code  large scale project management  and syntax hinting in many code editors  this is the correct way to do enumerations  underscore-notation variables    As demonstrated in the chart above and example below  here are five easy steps to get started   Determine a name for the enumeration group  Think of a noun that can describe the purpose of the enumeration or at least the entries in the enumeration  For example  a group of enumerations representing colors choosable by the user might be better named COLORCHOICES than COLORS  Decide whether enumerations in the group are mutually-exclusive or independent  If mutually-exclusive  start each enumerated variable name with ENUM   If independent or side-by-side  use INDEX   For each entry  create a new local variable whose name starts with ENUM  or INDEX   then the name of the group  then an underscore  then a unique friendly name for the property Add a ENUMLENGTH   ENUMLEN   INDEXLENGTH   or INDEXLEN   whether LEN  or LENGTH  is personal preference  enumerated variable at the very end  You should use this variable wherever possible in your code to ensure that adding an extra entry to the enumeration and incrementing this value won t break your code  Give each successive enumerated variable a value one more than the last  starting at 0  There are comments on this page that say 0 should not be used as an enumerated value because 0    null  0    false  0        and other JS craziness  I submit to you that  to avoid this problem and boost performance at the same time  always use     and never let    appear in your code except with typeof  e x  typeof X     string    In all my years of using      I have never once had a problem with using 0 as an enumeration value  If you are still squeamish  then 1 could be used as the starting value in ENUM  enumerations  but not in INDEX  enumerations  without performance penalty in many cases   const ENUM COLORENUM RED     0  const ENUM COLORENUM GREEN   1  const ENUM COLORENUM BLUE    2  const ENUMLEN COLORENUM      3      later on  if currentColor     ENUM COLORENUM RED          whatever    Here is how I remember when to use INDEX  and when to use ENUM      Precondition  var arr          arr INDEX     ENUM    However  ENUM  can  in certain circumstances  be appropriate as an index such as when counting the occurrences of each item   x000D   x000D  const ENUM PET CAT   0        ENUM PET DOG   1        ENUM PET RAT   2        ENUMLEN PET    3   var favoritePets    ENUM PET CAT  ENUM PET DOG  ENUM PET RAT                      ENUM PET DOG  ENUM PET DOG  ENUM PET CAT                      ENUM PET RAT  ENUM PET CAT  ENUM PET DOG    var petsFrequency        for  var i 0  i lt ENUMLEN PET  i i 1 0    petsFrequency i    0   for  var i 0  len favoritePets length 0  petId 0  i lt len  i i 1 0    petsFrequency petId   favoritePets i  0     petsFrequency petId  0    1 0   console log        cat   petsFrequency ENUM PET CAT        dog   petsFrequency ENUM PET DOG        rat   petsFrequency ENUM PET RAT      x000D   x000D   x000D   Observe that  in the code above  it s really easy to add in a new kind of pet  you would just have to append a new entry after ENUM PET RAT and update ENUMLEN PET accordingly  It might be more difficult and buggy to add a new entry in other systems of enumeration        Additionally  this syntax of enumerations allows for clear and concise class extending as seen below  To extend a class  add an incrementing number to the LEN  entry of the parent class  Then  finish out the subclass with its own LEN  entry so that the subclass may be extended further in the future    x000D   x000D   function window        use strict       var parseInt   window parseInt          use INDEX  when representing the index in an array instance     const INDEX PIXELCOLOR TYPE   0     is a ENUM PIXELTYPE           INDEXLEN PIXELCOLOR     1            INDEX SOLIDCOLOR R      INDEXLEN PIXELCOLOR 0            INDEX SOLIDCOLOR G      INDEXLEN PIXELCOLOR 1            INDEX SOLIDCOLOR B      INDEXLEN PIXELCOLOR 2            INDEXLEN SOLIDCOLOR     INDEXLEN PIXELCOLOR 3            INDEX ALPHACOLOR R      INDEXLEN PIXELCOLOR 0            INDEX ALPHACOLOR G      INDEXLEN PIXELCOLOR 1            INDEX ALPHACOLOR B      INDEXLEN PIXELCOLOR 2            INDEX ALPHACOLOR A      INDEXLEN PIXELCOLOR 3            INDEXLEN ALPHACOLOR     INDEXLEN PIXELCOLOR 4         use ENUM  when representing a mutually-exclusive species or type           ENUM PIXELTYPE SOLID   0            ENUM PIXELTYPE ALPHA   1            ENUM PIXELTYPE UNKNOWN   2            ENUMLEN PIXELTYPE      2       function parseHexColor inputString            var rawstr   inputString trim   substring 1           var result               if  rawstr length     8                result INDEX PIXELCOLOR TYPE    ENUM PIXELTYPE ALPHA              result INDEX ALPHACOLOR R    parseInt rawstr substring 0 2   16               result INDEX ALPHACOLOR G    parseInt rawstr substring 2 4   16               result INDEX ALPHACOLOR B    parseInt rawstr substring 4 6   16               result INDEX ALPHACOLOR A    parseInt rawstr substring 4 6   16             else if  rawstr length     4                result INDEX PIXELCOLOR TYPE    ENUM PIXELTYPE ALPHA              result INDEX ALPHACOLOR R    parseInt rawstr 0   16    0x11              result INDEX ALPHACOLOR G    parseInt rawstr 1   16    0x11              result INDEX ALPHACOLOR B    parseInt rawstr 2   16    0x11              result INDEX ALPHACOLOR A    parseInt rawstr 3   16    0x11            else if  rawstr length     6                result INDEX PIXELCOLOR TYPE    ENUM PIXELTYPE SOLID              result INDEX SOLIDCOLOR R    parseInt rawstr substring 0 2   16               result INDEX SOLIDCOLOR G    parseInt rawstr substring 2 4   16               result INDEX SOLIDCOLOR B    parseInt rawstr substring 4 6   16             else if  rawstr length     3                result INDEX PIXELCOLOR TYPE    ENUM PIXELTYPE SOLID              result INDEX SOLIDCOLOR R    parseInt rawstr 0   16    0x11              result INDEX SOLIDCOLOR G    parseInt rawstr 1   16    0x11              result INDEX SOLIDCOLOR B    parseInt rawstr 2   16    0x11            else               result INDEX PIXELCOLOR TYPE    ENUM PIXELTYPE UNKNOWN                    return result                the red component of green     console log parseHexColor   0f0   INDEX SOLIDCOLOR R           the alpha of transparent purple     console log parseHexColor   f0f7   INDEX ALPHACOLOR A            the enumerated array for turquoise     console log parseHexColor   40E0D0        self   x000D   x000D   x000D    Length  2 450 bytes  Some may say that this is less practical than other solutions  it wastes tons of space  it takes a long time to write  and it is not coated with sugar syntax  Those people would be right if they do not minify their code  However  no reasonable person would leave unminified code in the end product  For this minification  Closure Compiler is the best I have yet to find  Online access can be found here  Closure compiler is able to take all of this enumeration data and inline it  making your Javascript be super duper small and run super duper fast  Thus  Minify with Closure Compiler  Observe       Closure compiler is able to perform some pretty incredible optimizations via inferences that are way beyond the capacities of any other Javascript minifier  Closure Compiler is able to inline primitive variables set to a fixed value  Closure Compiler is also able to make inferences based upon these inlined values and eliminate unused blocks in if-statements and loops    x000D   x000D   use strict   function e  function d a  a a trim   substring 1  var b    8   a length  b 0  1 b 1  c a substring 0 2  16  b 2  c a substring 2 4  16  b 3  c a substring 4 6  16  b 4  c a substring 4 6  16   4   a length  b 1  17 c a 0  16  b 2  17 c a 1  16  b 3  17 c a 2  16  b 4  17 c a 3  16   6   a length  b 0  0 b 1  c a substring 0 2  16  b 2  c a substring 2 4  16  b 3  c a substring 4 6  16   3   a length  b 0  0 b 1  17 c a 0  16  b 2  17 c a 1  16  b 3  17 c a 2  16   b 0  2 return b var c  e parseInt console log d   0f0   1   console log d   f0f7   4   console log d   40E0D0      self   x000D   x000D   x000D    Length  605 bytes  Closure Compiler rewards you for coding smarter and organizing your code well because  whereas many minifiers punish organized code with a bigger minified file size  Closure Compiler is able to sift through all your cleanliness and sanity to output an even smaller file size if you use tricks like variable name enumerations  That  in this one mind  is the holy grail of coding  a tool that both assists your code with a smaller minified size and assists your mind by training better programming habits      Now  let us see how big the equivalent file would be without any of these enumerations   Source Without Using Enumerations  length  1 973 bytes  477 bytes shorter than enumerated code    Minified Without Using Enumerations  length  843 bytes  238 bytes longer than enumerated code     As seen  without enumerations  the source code is shorter at the cost of a larger minified code  I do not know about you  but I know for sure that I do not incorporate source code into the end product  Thus  this form of enumerations is far superior insomuch that it results in smaller minified file sizes       Another advantage about this form of enumeration is that it can be used to easily manage large scale projects without sacrificing minified code size  When working on a large project with lots of other people  it might be beneficial to explicitly mark and label the variable names with who created the code so that the original creator of the code can be quickly identified for collaborative bug fixing     JG   Jack Giffin const ENUM JG COLORENUM RED     0        ENUM JG COLORENUM GREEN   1        ENUM JG COLORENUM BLUE    2        ENUMLEN JG COLORENUM      3      later on  if currentColor     ENUM JG COLORENUM RED          whatever       PL   Pepper Loftus    BK   Bob Knight const ENUM PL ARRAYTYPE UNSORTED     0        ENUM PL ARRAYTYPE ISSORTED     1        ENUM BK ARRAYTYPE CHUNKED      2     added by Bob Knight       ENUM JG ARRAYTYPE INCOMPLETE   3     added by jack giffin       ENUMLEN PL COLORENUM           4      later on  if    randomArray     ENUM PL ARRAYTYPE UNSORTED      randomArray     ENUM BK ARRAYTYPE CHUNKED           whatever         Further  this form of enumeration is also much faster after minification  In normal named properties  the browser has to use hashmaps to look up where the property is on the object  Although JIT compilers intelligently cache this location on the object  there is still tremendous overhead due to special cases such as deleting a lower property from the object   But  with continuous non-sparse integer-indexed PACKED ELEMENTS arrays  the browser is able to skip much of that overhead because the index of the value in the internal array is already specified  Yes  according to the ECMAScript standard  all properties are supposed to be treated as strings  Nevertheless  this aspect of the ECMAScript standard is very misleading about performance because all browsers have special optimizations for numeric indexes in arrays      Hashmaps are slow  even with JIT juice var ref       ref count   10  ref value    quot foobar quot    Compare the code above to the code below      Arrays  however  are always lightning fast const INDEX REFERENCE COUNT   0  const INDEX REFERENCE VALUE   1  const INDEXLENGTH REFERENCE   2   var ref       ref INDEX REFERENCE COUNT    10  ref INDEX REFERENCE VALUE     quot foobar quot    One might object to the code with enumerations seeming to be much longer than the code with ordinary objects  but looks can be deceiving  It is important to remember that source code size is not proportional to output size when using the epic Closure Compiler  Observe      Hashmaps are slow  even with JIT juice var a  count 10 value  quot foobar quot     The minified code without enumerations is above and the minified code with enumerations is below      Arrays  however  are always lightning fast var a  10  quot foobar quot     The example above demonstrates that  in addition to having superior performance  the enumerated code also results in a smaller minified file size     Furthermore  this one s personal cherry on the top is using this form of enumerations along with the CodeMirror text editor in Javascript mode  CodeMirror s Javascript syntax highlighting mode highlights local variables in the current scope  That way  you know instantly when you type in a variable name correctly because if the variable name was previously declared with the var keyword  then the variable name turns a special color  cyan by default   Even if you do not use CodeMirror  then at least the browser throws a helpful  variable name  is not defined exception when executing code with mistyped enumeration names  Also  JavaScript tools such as JSLint and Closure Compiler are very loud about telling you when you mistype in an enumeration variable name  CodeMirror  the browser  and various Javascript tools put together make debugging this form of enumeration very simple and really easy    x000D   x000D  const ENUM COLORENUM RED     0        ENUM COLORENUM GREEN   1        ENUM COLORENUM BLUE    2        ENUMLEN COLORENUM      3  var currentColor   ENUM COLORENUM GREEN   if currentColor     ENUM COLORENUM RED          whatever    if currentColor     ENUM COLORENUM DNE          whatever   x000D   x000D   x000D   In the above snippet  you were alerted with an error because ENUM COLORENUM DNE does not exist    I think its safe to say that this methodology of enumeration is indeed the best way to go not just for minified code size  but also for performance  debugging  and collaboration

User · Answer

Simplest solution   Create  var Status   Object freeze        Connecting  0       Ready  1       Loading  2       Processing   3       Get Value  console log Status Ready     1   Get Key  console log Object keys Status  Status Ready      Ready

User · Answer

This can be useful  const  CATS  DOGS  BIRDS    ENUM     The implementation is simple and efficient  function   ENUM count 1    while true  yield count      A generator can yield the exact sequence of integers required  without knowing how many constants there are  It can also support an optional argument that specifies which  possibly negative  number to start from  defaulting to 1

User · Answer

IE8 does Not support freeze   method  Source  http   kangax github io compat-table es5   Click on  Show obsolete browsers   on top  and check IE8  amp  freeze row col intersection   In my current game project  I have used below  since few customers still use IE8   var CONST WILD TYPES         REGULAR   REGULAR       EXPANDING   EXPANDING       STICKY   STICKY       SHIFTING   SHIFTING       We could also do     var CONST WILD TYPES         REGULAR   RE       EXPANDING   EX       STICKY   ST       SHIFTING   SH       or even this     var CONST WILD TYPES         REGULAR   1       EXPANDING   2       STICKY   3       SHIFTING   4       The last one  seems most efficient for string  it reduces your total bandwidth if you have server  amp  client exchanging this data  Of course  now it s your duty to make sure there are no conflicts in the data  RE  EX  etc  must be unique  also 1  2  etc  should be unique   Note that you need to maintain these forever for backward compatibility     Assignment   var wildType   CONST WILD TYPES REGULAR    Comparision   if  wildType     CONST WILD TYPES REGULAR           do something here

User · Answer

I ve modified the solution of 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               Test   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

User · Answer

Simplest solution   Create  var Status   Object freeze        Connecting  0       Ready  1       Loading  2       Processing   3       Get Value  console log Status Ready     1   Get Key  console log Object keys Status  Status Ready      Ready

User · Answer

Create an object literal   const Modes       DRAGGING   drag     SCALING    scale     CLICKED    click

User · Answer

A quick and simple way would be    var Colors   function    return        WHITE  0       BLACK  1       RED  2       GREEN  3             console log Colors WHITE     this prints out  0

User · Answer

A quick and simple way would be    var Colors   function    return        WHITE  0       BLACK  1       RED  2       GREEN  3             console log Colors WHITE     this prints out  0

User · Answer

I wasn t satisfied with any of the answers  so I made Yet Another Enum  YEA     This implementation    uses more up-to-date JS requires just the declaration of this one class to easily create enums has mapping by name  colors RED   string  colors  RED     and index  colors 0    but you only need to pass in the strings as an array binds equivalent toString   and valueOf   functions to each enum object  if this is somehow not desired  one can simply remove it - small overhead for JS though  has optional global naming storage by name string freezes the enum object once created so that it can t be modified   Special thanks to Andre  Fi  s answer for some inspiration     The codes   class Enums     static create   name   undefined  items               let newEnum           newEnum length   items length      newEnum items   items      for  let itemIndex in items            Map by name        newEnum items itemIndex     parseInt itemIndex  10           Map by index        newEnum parseInt itemIndex  10     items itemIndex             newEnum toString   Enums enumToString bind newEnum       newEnum valueOf   newEnum toString        Optional naming and global registration      if  name    undefined          newEnum name   name        Enums name    newEnum              Prevent modification of the enum object      Object freeze newEnum       return newEnum        static enumToString         return  Enum            this name    undefined   this name                           this items toString                    Usage   let colors   Enums create     name   COLORS     items     RED    GREEN    BLUE    PORPLE           Global access  if named  Enums COLORS   colors items    Array 4     RED    GREEN    BLUE    PORPLE    colors length    4  colors RED    0 colors GREEN    1 colors BLUE    2 colors PORPLE    3 colors 0      RED  colors 1      GREEN  colors 2      BLUE  colors 3      PORPLE   colors toString       Enum COLORS  RED GREEN BLUE PORPLE      Enum frozen  makes it a real enum  colors RED   9001  colors RED    0

User · Answer

I had done it a while ago using a mixture of   defineGetter   and   defineSetter   or defineProperty depending on the JS version   Here s the enum generating function I made  https   gist github com gfarrell 6716853  You d use it like this   var Colours   Enum  RED    GREEN    BLUE      And it would create an immutable string int dictionary  an enum

User · Answer

I ve been playing around with this  as I love my enums      Using Object defineProperty I think I came up with a somewhat viable solution   Here s a jsfiddle  http   jsfiddle net ZV4A6   Using this method   you should  in theory  be able to call and define enum values for any object  without affecting other attributes of that object   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        Because of the attribute writable false this should make it type safe   So you should be able to create a custom object  then call Enum   on it  The values assigned start at 0 and increment per item   var EnumColors     EnumColors Enum  RED   BLUE   GREEN   YELLOW    EnumColors RED           0 EnumColors BLUE          1 EnumColors GREEN         2 EnumColors YELLOW        3

User · Answer

class Enum     constructor     vals        vals forEach  val   gt          const CONSTANT   Symbol val         Object defineProperty this  val toUpperCase              get                return CONSTANT                     set  val              const enum val    CONSTANT                generate TypeError associated with attempting to change the value of a constant           enum val   val                                      Example of usage   const COLORS   new Enum  red    blue    green

User · Answer

es7 way   iterator  freeze   usage   const ThreeWiseMen   new Enum  Melchior    Caspar    Balthazar    for  let name of ThreeWiseMen      console log name       with a given key let key   ThreeWiseMen Melchior  console log key in ThreeWiseMen     true  string conversion  also true   Melchior  in ThreeWiseMen   for  let entry from key enum       console log entry       prevent alteration  throws TypeError in strict mode  ThreeWiseMen Me    Me too   ThreeWiseMen Melchior name    Foo    code   class EnumKey        constructor props    Object freeze Object assign this  props          toString     return this name       export class Enum        constructor    keys             for  let  index  key  of keys entries                   Object defineProperty this  key                     value  new EnumKey   name key  index  enum this                     enumerable  true                                      Object freeze this                Symbol iterator               for  let key of Object keys this               yield this key              toString     return     this  join

User · Answer

Update 05 11 2020  Modified to include static fields and methods to closer replicate  quot true quot  enum behavior  Has anyone tried doing this with a class that contains private fields and  quot get quot  accessors  I realize private class fields are still experimental at this point but it seems to work for the purposes of creating a class with immutable fields properties  Browser support is decent as well  The only  quot major quot  browsers that don t support it are Firefox  which I m sure they will soon  and IE  who cares   DISCLAIMER  I am not a developer  I was just looking for an answer to this question and started thinking about how I sometimes create  quot enhanced quot  enums in C  by creating classes with private fields and restricted property accessors  Sample Class class Sizes          Private Fields     static   SMALL   0      static   MEDIUM   1      static   LARGE   2          Accessors for  quot get quot  functions only  no  quot set quot  functions      static get SMALL     return this   SMALL        static get MEDIUM     return this   MEDIUM        static get LARGE     return this   LARGE       You should now be able to call your enums directly  Sizes SMALL     0 Sizes MEDIUM     1 Sizes LARGE     2  The combination of using private fields and limited accessors means that the enum values are well protected  Sizes SMALL   10    Sizes SMALL is still 0 Sizes  SMALL   10    Sizes SMALL is still 0 Sizes   SMALL   10    Sizes SMALL is still 0

User · Answer

This is an old one I know  but the way it has since been implemented via the TypeScript interface is   var MyEnum   function  MyEnum        MyEnum MyEnum  Foo     0     Foo       MyEnum MyEnum  FooBar     2     FooBar       MyEnum MyEnum  Bar     1     Bar      MyEnum    MyEnum          This enables you to look up on both MyEnum Bar which returns 1  and MyEnum 1  which returns  Bar  regardless of the order of declaration

User · Answer

your answers are far too complicated  var buildSet   function array      var set         for  var i in array        var item   array i       set item    item        return set     var myEnum   buildSet   RED   GREEN   BLUE        myEnum RED     RED     etc

User · Answer

In ES7   you can do an elegant ENUM relying on static attributes    class ColorEnum        static RED   0       static GREEN   1      static BLUE   2      then   if  currentColor     ColorEnum GREEN      -- coding --      The advantage   of using class instead of literal object  is to have a parent class Enum then all your Enums will extends that class      class ColorEnum  extends Enum

User · Answer

Use Javascript Proxies  TLDR  Add this class to your utility methods and use it throughout your code  it mocks Enum behavior from traditional programming languages  and actually throws errors when you try to either access an enumerator that does not exist or add update an enumerator  No need to rely on Object freeze     class Enum     constructor enumObj        const handler           get target  name            if  typeof target name      undefined               return target name                     throw new Error  No such enumerator    name                    set             throw new Error  Cannot add update properties on an Enum instance after it is defined                       return new Proxy enumObj  handler           Then create enums by instantiating the class   const roles   new Enum     ADMIN   Admin     USER   User           Full Explanation    One very beneficial feature of Enums that you get from traditional languages is that they blow up  throw a compile-time error  if you try to access an enumerator which does not exist    Besides freezing the mocked enum structure to prevent additional values from accidentally maliciously being added  none of the other answers address that intrinsic feature of Enums   As you are probably aware  accessing non-existing members in JavaScript simply returns undefined and does not blow up your code  Since enumerators are predefined constants  i e  days of the week   there should never be a case when an enumerator should be undefined   Don t get me wrong  JavaScript s behavior of returning undefined when accessing undefined properties is actually a very powerful feature of language  but it s not a feature you want when you are trying to mock traditional Enum structures    This is where Proxy objects shine  Proxies were standardized in the language with the introduction of ES6  ES2015   Here s the description from MDN       The Proxy object is used to define custom behavior for fundamental operations  e g  property lookup  assignment  enumeration  function   invocation  etc     Similar to a web server proxy  JavaScript proxies are able to intercept operations on objects  with the use of  traps   call them hooks if you like  and allow you to perform various checks  actions and or manipulations before they complete  or in some cases stopping the operations altogether which is exactly what we want to do if and when we try to reference an enumerator which does not exist    Here s a contrived example that uses the Proxy object to mimic Enums  The enumerators in this example are standard HTTP Methods  i e   GET    POST   etc      x000D   x000D     Class for creating enums  13 lines  x000D     Feel free to add this to your utility library in  x000D     your codebase and profit  Note  As Proxies are an ES6  x000D     feature  some browsers clients may not support it and  x000D     you may need to transpile using a service like babel x000D   x000D  class Enum   x000D       The Enum class instantiates a JavaScript Proxy object  x000D       Instantiating a  Proxy  object requires two parameters   x000D       a  target  object and a  handler   We first define the handler  x000D       then use the handler to instantiate a Proxy  x000D   x000D       A proxy handler is simply an object whose properties x000D       are functions which define the behavior of the proxy  x000D       when an operation is performed on it   x000D     x000D       For enums  we need to define behavior that lets us check what enumerator x000D       is being accessed and what enumerator is being set  This can be done by  x000D       defining  get  and  set  traps  x000D    constructor enumObj    x000D      const handler     x000D        get target  name    x000D          if  typeof target name      undefined     x000D            return target name  x000D            x000D          throw new Error  No such enumerator    name    x000D           x000D        set     x000D          throw new Error  Cannot add update properties on an Enum instance after it is defined   x000D          x000D        x000D   x000D   x000D         Freeze the target object to prevent modifications x000D      return new Proxy enumObj  handler  x000D      x000D    x000D   x000D   x000D     Now that we have a generic way of creating Enums  lets create our first Enum  x000D  const httpMethods   new Enum   x000D    DELETE   DELETE   x000D    GET   GET   x000D    OPTIONS   OPTIONS   x000D    PATCH   PATCH   x000D    POST   POST   x000D    PUT   PUT  x000D     x000D   x000D     Sanity checks x000D  console log httpMethods DELETE  x000D     logs  DELETE  x000D   x000D  try   x000D    httpMethods delete    delete  x000D    catch  e    x000D  console log  Error     e message  x000D    x000D     throws  Cannot add update properties on an Enum instance after it is defined  x000D   x000D  try   x000D    console log httpMethods delete  x000D    catch  e    x000D    console log  Error     e message  x000D    x000D     throws  No such enumerator  delete  x000D   x000D   x000D      ASIDE  What the heck is a proxy   I remember when I first started seeing the word proxy everywhere  it definitely didn t make sense to me for a long time  If that s you right now  I think an easy way to generalize proxies is to think of them as software  institutions  or even people that act as intermediaries or middlemen between two servers  companies  or people

[javascript] What is the preferred syntax for defining enums in JavaScript?

Examples related to javascript

Examples related to syntax

Examples related to enums