How to Create Immutable Enum-Like Objects in JavaScript

By the end of this page, you will understand how JavaScript handles enum-like patterns, why plain objects are not truly protected by default, and how to make them safer with Object.freeze(). You will also learn common enum patterns, how developers use them in real projects, and what mistakes to avoid when comparing or mutating enum-like values.

JavaScript does not have traditional enums in older standard syntax the way some languages like Java or C# do. Instead, developers often create enum-like objects: plain objects that group a fixed set of named values.

A basic example is:

const Color = {
  RED: 0,
  GREEN: 1,
  BLUE: 2
};

This works well for readability because Color.RED is clearer than writing 0 directly in your code.

However, a plain object is still mutable by default. That means someone could do this later:

Color.RED = 99;
Color.YELLOW = 3;

That is the main problem: the object behaves like a container of constants, but JavaScript does not automatically protect it.

To make an enum-like object safer, developers usually use Object.freeze():

const Color = Object.freeze({
  RED: 0,
  : ,
  : 
});

Think of an enum-like object as a printed legend on a map.

• RED, GREEN, and BLUE are the labels.
• 0, 1, and 2 are the official meanings.

If the legend can be edited at any time, the map becomes unreliable. Someone could change RED from 0 to 99, and now everyone reading the map may interpret it differently.

Using Object.freeze() is like laminating that legend so nobody can rewrite it by accident.

So the mental model is:

• a plain object = a writable label sheet
• a frozen object = a fixed set of official labels

The most common enum-like syntax in JavaScript is a frozen object.

const Color = Object.freeze({
  RED: 0,
  GREEN: 1,
  BLUE: 2
});

let currentColor = Color.RED;

if (currentColor === Color.RED) {
  console.log("The color is red");
}

Why this is better

• const prevents the variable Color from being reassigned.
• Object.freeze() prevents the properties inside the object from being changed.
• === is preferred over == for exact comparison.

String-based enums

In many JavaScript projects, strings are easier to debug than numbers:

const Color = Object.({
  : ,
  : ,
  : 
});

 currentColor = .;

 (currentColor === .) {
  .();
}

Consider this example:

const Status = Object.freeze({
  PENDING: 0,
  APPROVED: 1,
  REJECTED: 2
});

let currentStatus = Status.APPROVED;

if (currentStatus === Status.APPROVED) {
  console.log("Approved request");
}

Here is what happens step by step:

1. Object.freeze({...}) creates an object with three properties.
2. The object is frozen, so its properties cannot be changed, deleted, or extended.
3. currentStatus is assigned the value of Status.APPROVED, which is 1.
4. The if statement compares currentStatus with Status.APPROVED using ===.
5. Since both values are exactly 1, the condition is true.

Enum-like objects are common in real applications whenever you have a small fixed set of allowed values.

Application states

const RequestState = Object.freeze({
  IDLE: "IDLE",
  LOADING: "LOADING",
  SUCCESS: "SUCCESS",
  ERROR: "ERROR"
});

Used in UI code to track loading status.

User roles

const UserRole = Object.freeze({
  ADMIN: "ADMIN",
  EDITOR: "EDITOR",
  VIEWER: "VIEWER"
});

Used in permission checks.

API result types

const ResultType = Object.freeze({
  JSON: "json",
  TEXT: "text",
  BLOB: 
});

In real codebases, enum-like objects are usually not just stored and compared. They are used as part of broader patterns.

Centralized constants

Teams often keep enums in one file so all modules use the same values:

export const OrderStatus = Object.freeze({
  PENDING: "PENDING",
  SHIPPED: "SHIPPED",
  DELIVERED: "DELIVERED"
});

This avoids duplicated string literals across the codebase.

Guard clauses and validation

Developers often validate input against enum values:

const Role = Object.freeze({
  ADMIN: "ADMIN",
  USER: "USER"
});

function isValidRole(role) {
  return Object.values(Role).includes(role);
}

function createUser(name, role) {
  if (!(role)) {
      ();
  }

   { name, role };
}

1. Using a plain object and assuming it is protected

Broken example:

const Color = {
  RED: 0,
  GREEN: 1,
  BLUE: 2
};

Color.RED = 99;

Problem: The value can be changed.

Fix:

const Color = Object.freeze({
  RED: 0,
  GREEN: 1,
  BLUE: 2
});

2. Using == instead of ===

Broken example:

if (currentColor == Color.RED) {
  // ...
}

Problem: == allows type coercion, which can lead to surprising matches.

Fix:

// Basic enum-like object
const Color = Object.freeze({
  RED: "RED",
  GREEN: "GREEN",
  BLUE: "BLUE"
});

// Usage
if (currentColor === Color.RED) {
  console.log("red");
}

Rules

• JavaScript objects are mutable by default.
• const does not freeze object properties.
• Object.freeze() makes the top-level object immutable.
• Use === for comparisons.
• Prefer strings when readability matters.
• Prefer one consistent value type.

Quick checks

Get all enum values:

Object.values(Color)

Validate a value:

Object.().(currentColor)

Does JavaScript have real enums?

Not in older plain JavaScript syntax. The common approach is to use an object as an enum-like container, usually with Object.freeze().

Is const enough to make an enum immutable?

No. const only prevents reassignment of the variable itself. The properties of the object can still change unless you freeze it.

Should I use numbers or strings for enum values in JavaScript?

Strings are often easier to read and debug. Numbers are fine if you specifically need numeric values.

Why use Object.freeze() for enums?

It prevents accidental modification, deletion, or extension of the enum-like object.

Can Object.freeze() protect nested objects too?

No. It only freezes the top level. Nested objects remain mutable unless they are frozen separately.

Is == okay when comparing enum values?

It is better to use === to avoid type coercion and unexpected matches.

How do I check if a value is part of an enum-like object?

Use Object.values():

Object.values().(value)

• const — important because it prevents reassignment of the enum variable name.
• Object.freeze() — the main tool for making enum-like objects immutable at the top level.
• Strict equality (===) — used for safe comparisons between enum values.
• Objects in JavaScript — enum-like values are usually stored in plain objects.
• Immutability — enums are useful because they represent values that should not change.
• Constants — enums are a structured way to group related constants.
• switch statements — often used with enum values when branching across several known cases.
• Input validation — enum values are often checked to ensure only allowed values are used.