Enum no TypeScript: Numeric e String 2026
Domine enums no TypeScript. Numeric, string, const enum e descubra quando union types são a escolha melhor.
Por que isso é importante
Enum no TypeScript: Numeric e String 2026. Domine enums no TypeScript. Numeric, string, const enum e descubra quando union types são a escolha melhor.
O Que É Enum no TypeScript
Enum (enumeração) é um tipo que define um conjunto de constantes nomeadas. Pensa numa lista fixa de opções: status de pedido, direções, roles de usuário, dias da semana.
No JavaScript não existe enum nativo. O pessoal resolve com objetos const ou strings soltas. Funciona, mas não tem proteção de tipo. O TypeScript trouxe enums como feature própria da linguagem.
Existem três sabores de enum: numeric (padrão, valores são números), string (valores são strings) e const enum (desaparece na compilação, vira só os valores inline). Cada um tem seu caso de uso.
Mas atenção: enums geram código JavaScript real na compilação. Isso aumenta o bundle. Por isso, muitos projetos modernos preferem union types pra casos simples. Vamos ver quando cada abordagem faz mais sentido.
Como Usar Enum Passo a Passo
Segue esse caminho e você usa enums com confiança:
- Passo 1: Identifique valores que formam um grupo fechado. Status, categorias, permissões. Se a lista é fixa e conhecida, enum pode ser boa escolha.
- Passo 2: Decida entre numeric e string enum. String enum é mais legível no debug e nos logs. Numeric é padrão e ocupa menos espaço.
- Passo 3: Crie o enum com a keyword
enum. Use PascalCase pro nome e UPPER_CASE ou PascalCase pros membros. - Passo 4: Use o enum como tipo nas funções, variáveis e interfaces. O TypeScript só aceita valores do enum, nada mais.
- Passo 5: Precisa de performance no bundle? Use
const enum. Ele desaparece no JavaScript final. - Passo 6: Lista simples com 2-4 opções? Considere union type ao invés de enum. Menos overhead, mesma segurança.
Exemplos Práticos
Começando pelo numeric enum, o tipo padrão:
// Numeric enum - valores começam em 0
enum Direction {
Up, // 0
Down, // 1
Left, // 2
Right, // 3
}
// Você pode definir o valor inicial
enum HttpStatus {
OK = 200,
Created = 201,
BadRequest = 400,
NotFound = 404,
ServerError = 500,
}
function handleResponse(status: HttpStatus) {
if (status === HttpStatus.OK) {
console.log("Tudo certo!");
}
}
handleResponse(HttpStatus.OK); // funciona
// handleResponse(999); // ERRO! não faz parte do enum
String enums. Bem mais legíveis nos logs e no debug:
// String enum - cada membro tem valor string
enum OrderStatus {
Pending = "PENDING",
Processing = "PROCESSING",
Shipped = "SHIPPED",
Delivered = "DELIVERED",
Cancelled = "CANCELLED",
}
interface Order {
id: number;
status: OrderStatus;
total: number;
}
const order: Order = {
id: 1,
status: OrderStatus.Pending,
total: 299.90,
};
// No console: { id: 1, status: "PENDING", total: 299.9 }
// Muito mais legível que ver o número 0
Const enum: zero impacto no bundle.
// Const enum - desaparece na compilação
const enum Color {
Red = "RED",
Green = "GREEN",
Blue = "BLUE",
}
const cor = Color.Red;
// No JavaScript compilado: const cor = "RED";
// O enum some completamente. Só fica o valor inline.
// Reverse mapping - só funciona com numeric enums
enum Role {
Admin, // 0
User, // 1
Guest, // 2
}
console.log(Role.Admin); // 0
console.log(Role[0]); // "Admin" (reverse mapping)
console.log(Role[1]); // "User"
Enum vs union type. A comparação que todo mundo quer ver:
// Abordagem com enum
enum Theme {
Light = "light",
Dark = "dark",
System = "system",
}
// Abordagem com union type (mais leve)
type Theme2 = "light" | "dark" | "system";
// As duas funcionam como tipo
function setTheme(theme: Theme) { /* ... */ }
function setTheme2(theme: Theme2) { /* ... */ }
// Diferença: enum gera JavaScript, union não
// Union é só tipagem - desaparece 100% na compilação
// Quando enum ganha:
// - Precisa iterar sobre os valores
// - Quer reverse mapping
// - Valores são usados em runtime (switch, comparação)
// Quando union ganha:
// - Lista simples, poucas opções
// - Bundle size importa
// - Só precisa de checagem de tipo
Erros Comuns
Ciladas que pegam até dev experiente
Erro 1: Misturar valores numéricos e strings no mesmo enum. TypeScript deixa, mas cria confusão. Escolha um tipo e mantenha.
Erro 2: Usar const enum com isolatedModules (comum em projetos React/Vite). Const enums não funcionam com esse flag porque precisam ser resolvidos em tempo de compilação entre arquivos.
Erro 3: Comparar numeric enum com número literal. 'status === 0' funciona, mas perde toda a legibilidade. Sempre compare com o membro: 'status === Role.Admin'.
Erro 4: Criar enum pra 2 opções. 'enum Boolean { Yes, No }' é overengineering. Use um simples boolean ou union type: 'type Answer = "yes" | "no"'.
Erro 5: Esquecer que enums são bidirecionais (numeric). Role[0] retorna 'Admin'. Isso é útil mas confunde se você não sabe que existe.
Checklist: Uso de Enums
- Valores formam um grupo fechado e fixo (status, categorias, roles).
- Escolhi entre string enum e numeric enum com critério claro.
- Const enum usado apenas quando isolatedModules está desligado.
- Não misturei tipos de valores dentro do mesmo enum.
- Comparações usam membros do enum, não valores literais.
- Considerei union type pra listas simples com poucas opções.
- Enum tem nome em PascalCase e está num arquivo acessível.
- Testei que o TypeScript rejeita valores fora do enum.
TypeScript na prática, não na teoria
Enums são só uma peça do quebra-cabeça. No CrazyStack, você usa TypeScript em todo o stack: enums pra status de agendamento, roles de usuário, tipos de pagamento. Tudo num projeto SaaS completo que funciona de ponta a ponta.
Você sai do curso com código profissional no portfólio. Backend Node.js, frontend React, banco com Prisma, deploy no ar. Não é exercício acadêmico. É produto de verdade.
Perguntas frequentes
O Que É Enum no TypeScript
Enum (enumeração) é um tipo que define um conjunto de constantes nomeadas. Pensa numa lista fixa de opções: status de pedido, direções, roles de usuário, dias da semana. No JavaScript não existe enum nativo. O pessoal resolve com objetos const ou strings soltas. Funciona, mas não tem proteção de tipo. O TypeScript trouxe enums como feature própria da linguagem. Existem três sabores de enum: numeric (padrão, valores são números), string (valores são strings) e const enum (desaparece na compilação, vira só os valores inline). Cada um tem seu caso de uso.
Como Usar Enum Passo a Passo
Segue esse caminho e você usa enums com confiança: