Enums in JavaScript?

0 votes
asked Nov 13, 2008 by david-citron

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?

29 Answers

0 votes
answered Nov 13, 2008 by gareth

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.

0 votes
answered Nov 21, 2009 by randolpho

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


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.


While it probably doesn't fit every valid use of enums, it goes a very long way.

0 votes
answered Nov 4, 2010 by stijn-de-witt

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)

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 hardcoded, 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 hashtable. A set of name-value pairs. You can loop through them or otherwise manipulate them without knowing much about them in advance.


for (var sz in SIZE) {
  // sz will be the names of the objects in SIZE, so
  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 btw, 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

0 votes
answered Nov 13, 2011 by andre-fi

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');
0 votes
answered Nov 18, 2011 by artur-czajka

I can't post comment to THE answer, so I guess I'd bump the thread since it shows up high in Google.

Since 1.8.5 it's possible to seal and freeze the object, so define the above as:

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


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

and voila! JS enums ;)

source: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/freeze

IMHO quotes aren't needed but I kept them for consistency.

0 votes
answered Nov 15, 2012 by chris

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 < length; ++i){

Enum.prototype.addEnum = function(e) {

Enum.prototype.getByName = function(name) {
    return this[name];

Enum.prototype.getByValue = function(field, value) {
    var lookup = this._lookups[field];
    if(lookup) {
        return lookup[value];
    } else {
        this._lookups[field] = ( lookup = {});
        var k = this._enums.length - 1;
        for(; k >= 0; --k) {
            var m = this._enums[k];
            var j = m[field];
            lookup[j] = m;
            if(j == value) {
                return m;
    return null;

function defineEnum(definition) {
    var k;
    var e = new Enum();
    for(k in definition) {
        var j = definition[k];
        e[k] = j;
    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.getByValue('value', 1).string

    // 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
0 votes
answered Nov 24, 2012 by yaroslav

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
0 votes
answered Nov 1, 2013 by user2254487

A quick and simple way would be :

var Colors = function(){
return {

console.log(Colors.WHITE)  //this prints out "0"
0 votes
answered Nov 21, 2013 by duncan

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], {
        return this;

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.RED;    // == 0
EnumColors.BLUE;   // == 1
EnumColors.GREEN;  // == 2
EnumColors.YELLOW; // == 3
0 votes
answered Nov 24, 2013 by rob-hardy

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.

Welcome to Q&A, where you can ask questions and receive answers from other members of the community.
Website Online Counter