Verificação de existência de valor em Enum TypeScript: guia completo

Por que verificar um valor em Enum TypeScript? Exemplo prático da vida real

Imagine: você está escrevendo um backend em Node.js com TypeScript. O cliente envia o status de um pedido — uma string "shipped". Você tem um enum OrderStatus com as opções: Pending, Processing, Shipped, Delivered. Mas de repente chega "CANCELLED" ou "unknown". O que fazer? Correto — verificar se o valor existe no enum TypeScript.

Esta tarefa é uma das mais frequentes no Stack Overflow (milhares de visualizações). E não é à toa: enum no TypeScript não é apenas um conjunto de constantes, mas uma fera complicada com variantes numéricas e de string. Neste guia, abordaremos todas as formas de verificar a existência de um valor em um enum, desde as simples até as avançadas, com exemplos de código e explicações.

Se você está começando a aprender TypeScript ou quer aprofundar seus conhecimentos — este artigo é para você. Vamos lá!

O que é um Enum em TypeScript? Breve introdução

Enum (enumeração) é uma forma de definir um conjunto de constantes nomeadas. No TypeScript, existem dois tipos de enum:

\n
• Enums numéricos — os valores são incrementados automaticamente (0, 1, 2...).
\n
• Enums de string — a cada membro é atribuída explicitamente uma string.
\n

Exemplo de enum numérico:

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

Exemplo de enum de string:

enum Status {\n    Active = "ACTIVE",\n    Inactive = "INACTIVE",\n    Pending = "PENDING"\n}

Por que verificar um valor? Porque dados externos (API, formulários, bancos de dados) podem ser qualquer coisa. Sem verificação, você corre o risco de obter undefined ou um erro em tempo de execução.

Método 1. Clássico: Object.values() + includes()

A forma mais popular e legível é transformar o enum em um array de valores e verificar a ocorrência usando includes().

Para enums de string:

enum Color {\n    Red = "RED",\n    Green = "GREEN",\n    Blue = "BLUE"\n}\n\nfunction isColor(value: string): boolean {\n    return Object.values(Color).includes(value as Color);\n}\n\nconsole.log(isColor("RED"));    // true\nconsole.log(isColor("YELLOW")); // false

Para enums numéricos — um truque! Object.values() retorna um mapeamento reverso (chaves e valores). Portanto, é necessário filtrar apenas os números:

enum NumberEnum {\n    A = 1,\n    B = 2,\n    C = 3\n}\n\nfunction isNumberEnumValue(value: number): boolean {\n    return Object.values(NumberEnum).filter(v => typeof v === 'number').includes(value);\n}\n\nconsole.log(isNumberEnumValue(2)); // true\nconsole.log(isNumberEnumValue(5)); // false

Esta abordagem é universal, mas requer cuidado com enums numéricos. Ponto positivo: simples e claro. Ponto negativo: é preciso lembrar da filtragem.

Método 2. Type Guard: verificação através das chaves do enum

Se você precisa não apenas verificar o valor, mas também obter uma garantia de tipo, use um type guard. Este método é especialmente útil ao trabalhar com APIs, onde você deseja restringir o tipo.

enum UserRole {\n    Admin = "admin",\n    User = "user",\n    Guest = "guest"\n}\n\nfunction isUserRole(value: string): value is UserRole {\n    return Object.values(UserRole).includes(value as UserRole);\n}\n\nfunction processRole(role: string) {\n    if (isUserRole(role)) {\n        // TypeScript sabe que role é UserRole\n        console.log(`Função: ${role}`);\n    } else {\n        console.log("Função desconhecida");\n    }\n}\n\nprocessRole("admin"); // Função: admin\nprocessRole("moderator"); // Função desconhecida

Esta abordagem fornece segurança de tipos e reduz o número de verificações no código. Recomendo para projetos sérios.

Método 3. Helper personalizado