TypeScript Enum: Numeric, String and const Enums

A TypeScript enum is a named set of constants. enum Direction { Up, Down, Left, Right } creates both a type, Direction, and a runtime object whose members you access as Direction.Up. Members are numbered from 0 unless you give them values, and string enums give each member a readable string.

enum Direction {
    Up,    // 0
    Down,  // 1
    Left,  // 2
    Right, // 3
}

enum Status {
    Active = "ACTIVE",
    Inactive = "INACTIVE",
}

function move(dir: Direction): string {
    return `moving ${Direction[dir]} (${dir})`;
}

console.log(move(Direction.Left)); // moving Left (2)
console.log(Status.Active);        // ACTIVE

let current: Status = Status.Inactive;
console.log(current === Status.Inactive); // true

Enums are one of the few TypeScript features that are not just types: an enum becomes a real JavaScript object when the code is compiled.

Numeric Enums

Without initializers, members get 0, 1, 2 and so on. Give the first member a number and the rest continue from it. You can also set every value explicitly, which is the safe choice when the numbers are stored in a database or sent over the network.

enum Priority {
    Low = 1,
    Medium, // 2
    High,   // 3
}

enum HttpStatus {
    Ok = 200,
    NotFound = 404,
    ServerError = 500,
}

// Bit flags: combine members with |, test with &
enum Permission {
    None = 0,
    Read = 1 << 0,  // 1
    Write = 1 << 1, // 2
    Delete = 1 << 2, // 4
    All = Read | Write | Delete, // 7
}

console.log(Priority.High, HttpStatus.NotFound); // 3 404

const mine = Permission.Read | Permission.Write;
console.log(mine, (mine & Permission.Write) !== 0, (mine & Permission.Delete) !== 0); // 3 true false

Relying on auto-numbering is fine for values that never leave the program. If the order of members might change, and the numbers are persisted anywhere, inserting a member in the middle silently renumbers everything after it.

What an Enum Compiles To

Types are erased, but an enum is not. This is the JavaScript TypeScript emits for a numeric and a string enum:

enum Direction { Up, Down, Left, Right }
enum Status { Active = "ACTIVE", Inactive = "INACTIVE" }

var Direction;
(function (Direction) {
    Direction[Direction["Up"] = 0] = "Up";
    Direction[Direction["Down"] = 1] = "Down";
    Direction[Direction["Left"] = 2] = "Left";
    Direction[Direction["Right"] = 3] = "Right";
})(Direction || (Direction = {}));
var Status;
(function (Status) {
    Status["Active"] = "ACTIVE";
    Status["Inactive"] = "INACTIVE";
})(Status || (Status = {}));

Direction["Up"] = 0 returns 0, so Direction[0] = "Up" is set in the same statement. A numeric enum therefore maps both ways: name to number and number back to name. That is the reverse mapping. String enums only map names to values.

enum Direction { Up, Down, Left, Right }
enum Status { Active = "ACTIVE", Inactive = "INACTIVE" }

console.log(Direction);
console.log(Direction[2]);    // Left: number to name
console.log(Direction.Left);  // 2: name to number
console.log(Status);          // { Active: 'ACTIVE', Inactive: 'INACTIVE' }

The printed Direction object has eight keys: the four names and the four numbers. That matters as soon as you iterate over it.

String Enums

Each member of a string enum needs an explicit string value. The values show up as-is in logs, JSON and databases, which makes string enums easier to debug than numbers.

A string enum is nominal in one way that surprises people: a plain string is not assignable to it, even when the text matches a member's value.

// This does not compile: "ACTIVE" is a string, not a Status.
enum Status {
    Active = "ACTIVE",
    Inactive = "INACTIVE",
}

let current: Status = "ACTIVE";
console.log(current);

index.ts(7,5): error TS2820: Type '"ACTIVE"' is not assignable to type 'Status'. Did you mean 'Status.Inactive'?

(The suggestion in the message is a guess by the compiler and is wrong here; the fix is Status.Active.) In the other direction, a Status value can be used wherever a string is expected. When values arrive as strings, from JSON or a form, convert them with a check like the one in the section on checking values below.

Using an Enum as a Type

The enum name is a type whose values are its members. Combined with switch, TypeScript checks that every member is handled when the function must return a value:

enum Shape { Circle = "circle", Square = "square", Triangle = "triangle" }

function sides(shape: Shape): number {
    switch (shape) {
        case Shape.Circle: return 0;
        case Shape.Square: return 4;
        case Shape.Triangle: return 3;
    }
}

console.log(sides(Shape.Square)); // 4

// Numeric enums accept any number, not only member values:
enum Level { Low, High }
const fromDb: number = 57;
const level: Level = fromDb; // compiles
console.log(level);           // 57

If a new member is added to Shape without a new case, sides stops compiling with TS2366, Function lacks ending return statement and return type does not include 'undefined'. The switch page shows the stricter never-based exhaustive check.

The last lines show a real weakness of numeric enums. A number literal that matches no member, const level: Level = 99, is a compile error (TS2322), but any value typed number is accepted, so 57 gets through. String enums do not have this hole.

Iterating Over an Enum

An enum is an object at runtime, so Object.keys, Object.values and Object.entries work. For a string enum they return exactly the members. For a numeric enum they also return the reverse-mapping entries, which you filter out:

enum Status { Active = "ACTIVE", Inactive = "INACTIVE", Banned = "BANNED" }
enum Direction { Up, Down, Left, Right }

console.log(Object.keys(Status));   // [ 'Active', 'Inactive', 'Banned' ]
console.log(Object.values(Status)); // [ 'ACTIVE', 'INACTIVE', 'BANNED' ]

for (const [name, value] of Object.entries(Status)) {
    console.log(`${name} = ${value}`);
}

// Numeric enum: keys include "0", "1", ... from the reverse mapping
const names = Object.keys(Direction).filter((k) => isNaN(Number(k)));
const values = Object.values(Direction).filter((v) => typeof v === "number");
console.log(names);  // [ 'Up', 'Down', 'Left', 'Right' ]
console.log(values); // [ 0, 1, 2, 3 ]

To type a variable as "one of the enum's member names", use keyof typeof Direction, which is the union "Up" | "Down" | "Left" | "Right". Then Direction[name] looks the value up with full type safety.

A string enum has no reverse mapping, so to get a member's name from its value, search the entries: Object.entries(Status).find(([, v]) => v === "ACTIVE")?.[0] is "Active", or undefined when no member has that value.

Checking if a Value Is in an Enum

Data from outside the program is a plain string or number. A type guard checks it against the enum's values and narrows it to the enum type:

enum Status { Active = "ACTIVE", Inactive = "INACTIVE" }

function isStatus(value: string): value is Status {
    return (Object.values(Status) as string[]).includes(value);
}

function parseStatus(raw: string): Status {
    if (!isStatus(raw)) throw new Error(`unknown status: ${raw}`);
    return raw; // narrowed to Status
}

console.log(parseStatus("ACTIVE") === Status.Active); // true
try {
    parseStatus("DELETED");
} catch (e) {
    if (e instanceof Error) console.log(e.message); // unknown status: DELETED
}

// Enum member name from a string key:
const key: string = "Inactive";
console.log(Status[key as keyof typeof Status]); // INACTIVE

Avoid raw as Status on untrusted input: the assertion compiles, but nothing is checked at runtime, so "DELETED" would travel through the program typed as a valid Status.

const Enums

const enum asks the compiler to delete the enum and write each member's value where it is used. There is no object at runtime, so nothing can be iterated or reverse-mapped.

const enum Size {
    Small = 1,
    Medium = 2,
    Large = 3,
}

const chosen = Size.Large;
console.log(chosen); // 3

// Emitted JavaScript for the line above:
//   const chosen = 3 /* Size.Large */;
// There is no Size object; Object.keys(Size) is a compile error (TS2475).

const enum saves a few bytes and a property lookup, but it depends on the compiler seeing the enum's declaration when it compiles every file that uses it. Tools that transpile one file at a time, such as Babel and swc, cannot see a const enum declared in another file; Node's type stripping rejects const enums like every other enum; and with isolatedModules or verbatimModuleSyntax TypeScript reports error TS2748 when you use a const enum from a declaration file. Most application code does not need const enums.

Enum vs Union Type vs as const Object

There are three common ways to define a fixed set of values:

// 1. Enum
enum ColorEnum { Red = "red", Green = "green" }

// 2. Union of string literals: types only, nothing at runtime
type ColorUnion = "red" | "green";

// 3. as const object: runtime values plus a derived union type
const Color = { Red: "red", Green: "green" } as const;
type Color = (typeof Color)[keyof typeof Color]; // "red" | "green"

function paintEnum(c: ColorEnum) { return `enum ${c}`; }
function paintUnion(c: ColorUnion) { return `union ${c}`; }
function paintConst(c: Color) { return `const ${c}`; }

console.log(paintEnum(ColorEnum.Red)); // needs the enum member
console.log(paintUnion("red"));        // plain strings work
console.log(paintConst(Color.Red), paintConst("green")); // both work
console.log(Object.values(Color));     // [ 'red', 'green' ]

Many teams now default to a union of string literals, and switch to the as const object when they need the values at runtime (to iterate them or build a dropdown). The reasons: unions are pure types and disappear from the output; they accept the plain strings that JSON and APIs deliver; and enums are the one piece of everyday TypeScript that is not "JavaScript plus erasable types".

That last point has become practical. Node runs .ts files directly by stripping the types, and an enum is not something it can strip:

node status.ts

SyntaxError [ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX]: TypeScript enum is not supported in strip-only mode

Node's --experimental-transform-types flag makes enums run, and the compiler option erasableSyntaxOnly reports every enum as error TS1294, This syntax is not allowed when 'erasableSyntaxOnly' is enabled., so a project can forbid them up front. See running TypeScript for how type stripping works. None of this makes enums wrong: code compiled with tsc or a bundler runs them fine, and a codebase that already uses enums gains little from converting.