Working with Enums

Enums são uma coleção de valores que são acessadas pelos nome

Assim basta declaramos com:

function calculateTax(amount: number): number {
    return amount * 1.2;
}

function writePrice(product: string, price: number): void {
    console.log(`Price for ${product}: $${price.toFixed(2)}`);
}

enum Product { Hat, Gloves, Umbrella }

let products: [Product, number][] = [[Product.Hat, 100], [Product.Gloves, 75]];

products.forEach((prod: [Product, number]) => {
    switch (prod[0]) {
        case Product.Hat:
            writePrice("Hat", calculateTax(prod[1]));
            break;
        case Product.Gloves:
            writePrice("Gloves", calculateTax(prod[1]));
            break;
        case Product.Umbrella:
            writePrice("Umbrella", calculateTax(prod[1]));
            break;
    }
});

Understanding how Enums works

Eles são implementados pelo compilador e, em tempo de execução, viram código JavaScript padrão.

Cada valor de um enum recebe automaticamente um número inteiro sequencial, começando em 0 por padrão.

Podemos trabalhar com os valores de um Enum dentro de um array:

function calculateTax(amount: number): number {
    return amount * 1.2;
}

function writePrice(product: string, price: number): void {
    console.log(`Price for ${product}: $${price.toFixed(2)}`);
}

enum Product { Hat, Gloves, Umbrella }

[Product.Hat, Product.Gloves, Product.Umbrella].forEach(val => {
    console.log(`Number value: ${val}`);
})

Como o Enum não é iteravel, podemos usar deste modo para iterar sobre ele, já que criando um array com os valores dele teremos isso:

[Product.Hat, Product.Gloves, Product.Umbrella].forEach(val => {
    console.log(`Number value: ${val}`);
})

Como o Enum é implementado usando valores numeros do JS um Enum pode ser atribuído a um número e exibido como um valor numérico:

function calculateTax(amount: number): number {
    return amount * 1.2;
}

function writePrice(product: string, price: number): void {
    console.log(`Price for ${product}: $${price.toFixed(2)}`);
}

enum Product { Hat, Gloves, Umbrella }

let productValue: Product = 0;
let productName: string = Product[productValue];
console.log(`Value: ${productValue}, Name: ${productName}`)

O compilador enforça a checagem de type para enums, que significa que você vai receber um error se você tentar comprar valores de diferentes enums, a menos que eles tenham o mesmo valor numérico

Enums proveem um array-indexer de estilo sintatito que pode ser usado para obter o nome do valor, como isso:

let productName: string = Product[productValue];

Using a Specific Enum Values

Ótimo trecho! Vamos organizar e explicar o que está acontecendo com Enums no TypeScript quando usamos valores específicos ou expressões:

1. Valores padrão

Por padrão, o compilador atribui números sequenciais começando em 0:

enum Product {
    Hat,       // 0
    Gloves,    // 1
    Umbrella   // 2
}

No arquivo de declaração (index.d.ts), isso aparece como:

declare enum Product {
    Hat = 0,
    Gloves = 1,
    Umbrella = 2
}

2. Valores constantes definidos pelo programador

Você pode atribuir manualmente um valor a um item do enum. O compilador continua incrementando a partir desse valor:

enum Product {
    Hat,         // 0
    Gloves = 20, // definido manualmente
    Umbrella     // 21 (gerado automaticamente)
}

No .d.ts:

declare enum Product {
    Hat = 0,
    Gloves = 20,
    Umbrella = 21
}

Usando expressões

O compilador também consegue avaliar expressões simples para definir valores:

enum OtherEnum { First = 10, Two = 20 }

enum Product {
    Hat = OtherEnum.First + 1,   // 11
    Gloves = 20,                 // definido manualmente
    Umbrella = Hat + Gloves      // 31
}

No .d.ts:

declare enum Product {
    Hat = 11,
    Gloves = 20,
    Umbrella = 31
}

Ou seja:

Hat usa o valor de outro enum (OtherEnum.First + 1).
Umbrella é calculado como Hat + Gloves.
O compilador resolve essas expressões em tempo de compilação.

Using String Enums

Por padrão o compilador usa numeros para representar os enums, mas podemos usar valores strings para enums:

function calculateTax(amount: number): number {
    return amount * 1.2;
}

function writePrice(product: string, price: number): void {
    console.log(`Price for ${product}: $${price.toFixed(2)}`);
}

enum OtherEnum { First = 10, Two = 20 }

enum Product { Hat = OtherEnum.First + 1, Gloves = 20, Umbrella = Hat + Gloves }

let productValue: Product = 0;
let productName: string = Product[productValue];

console.log(`Value: ${productValue}, Name: ${productName}`);

enum City { London = "London", Paris = "Paris", NY = "New York"}

console.log(`City: ${City.London}`)

Understanding the Limitations of Enums

Enums podem até ser uteis mas como a vida não é um morango, ele possui limitações porque eles são implementadas inteiramente pelo compilador TypeScript e traduzido para JS

Understanding the Value-Checking Limitation

O compilador é excelente na checagem dos tipos para Enums mas isso não faz nada para valores númericos legais que são usados

let productValue: Product = 0;

O compilador não previne a atribuição de um número para uma variável que o tipo é um enum quando o número não correspondente para um dos valores enum, que é o porque a saida contem undefined porque o lookup fails procura uma correspondencia Product para um valor numérico

O mesmo problema afeta se a função usa um enum como seu tipo de retorno porque o compilador irá permitir isso para retornar qualquer valor numérico

Understanding the Type Guard Limitation

Um problema relacionado surge quando usamos um type guard. Testagem de tipos é feita usando a keyword do JS typeof e enums são implementados usando valores numericos, typeof não pode ser usado para ser distinguir entre valores enum e number:

function calculateTax(amount: number): number {
    return amount * 1.2;
}

function writePrice(product: string, price: number): void {
    console.log(`Price for ${product}: $${price.toFixed(2)}`);
}

enum OtherEnum { First = 10, Two = 20 }
enum Product { Hat = OtherEnum.First + 1 , Gloves = 20, Umbrella = Hat + Gloves }

let productValue: Product = Product.Hat;
if (typeof productValue === "number") {
    console.log("Value is a number");
}

let unionValue: number | Product = Product.Hat;
if (typeof unionValue === "number") {
    console.log("Value is a number");
}

Using constant Enums

Enums em TypeScript são usados para representar conjuntos de valores nomeados, mas quando definidos como const enum, o compilador substitui cada referência diretamente pelo valor numérico correspondente, sem criar o objeto JavaScript que normalmente permite a busca reversa (valor → nome). Isso reduz o tamanho do código gerado e pode trazer uma pequena melhoria de desempenho, porém elimina a possibilidade de acessar o nome de um membro pelo seu valor. Em resumo, enums normais oferecem mais flexibilidade, enquanto const enums priorizam eficiência e simplicidade no código compilado.

Em TypeScript sem const, um Enum normal:

enum Product { Hat, Gloves, Umbrella }
let productValue = Product.Hat;

Assim que compilado:

var Product;
(function (Product) {
    Product[Product["Hat"] = 0] = "Hat";
    Product[Product["Gloves"] = 1] = "Gloves";
    Product[Product["Umbrella"] = 2] = "Umbrella";
})(Product || (Product = {}));

let productValue = Product.Hat; // usa o objeto Product

Aqui o objeto Product existe em tempo de execução permite fazer:

console.log(Product[0]); // "Hat"

Usando com const:

const enum Product { Hat, Gloves, Umbrella }
let productValue = Product.Hat;

Quando compila:

let productValue = 0 /* Hat */;

Vantagens e Limitações

Vantagem:

Código mais enxuto e rápido (sem criar objetos extras).
Pequeno ganho de performance.

Limitação:

Não é possível fazer lookup reverso (Product[0]).
Só aceita valores constantes ou expressões simples.
Se tentar acessar como objeto, dá erro:

19 November 2025