Enums são comuns na programação moderna, usados para modelar categorias como estados de semáforos ou dias da semana. No TypeScript, evoluíram de mapeamentos simples para estruturas mais complexas.

Uma vantagem dos enums é facilitar o mapeamento de listas curtas de valores em números, tornando comparações mais simples. Este artigo explora diferentes métodos para iterar sobre enums no TypeScript.

Resposta rápida

Se precisar extrair chaves ou valores numéricos de um objeto no JavaScript, aqui estão três abordagens comuns:

• Use Object.keys() com filtragem para obter chaves que representam números.
• Use Object.values() e filtre valores que sejam números.
• Use Object.entries() para filtrar chaves e valores com base em serem numéricos.

// Opção 1: Obter apenas chaves numéricas (chaves como strings, filtrar as que convertem para números) const numericKeys = Object.keys(obj).filter(key => !isNaN(Number(key)));

// Opção 2: Obter apenas valores numéricos const numericValues = Object.values(obj).filter(value => typeof value === 'number');

// Opção 3: Obter entradas com chaves ou valores numéricos (exemplo de filtro personalizado) const numericEntries = Object.entries(obj).filter(([key, value]) => !isNaN(Number(key)) || typeof value === 'number');

Por que iterar através de enums no TypeScript?

Os enums no TypeScript são objetos simples. Por exemplo:

enum TrafficLight { Green = 1, Yellow, Red }

Na definição acima, Green é mapeado para o número 1. Os membros subsequentes são mapeados para inteiros autoincrementados.

Às vezes, queremos iterar sobre um enum do TypeScript para realizar ações, como renderizar opções em uma UI ou validar valores de entrada.

Casos de uso e tipos de enums

Antes de explorar técnicas de iteração, é importante entender quais métodos funcionam melhor dependendo do tipo de enum com que você está lidando.

Enums numéricos criam um mapeamento reverso que inclui chaves e valores numéricos, exigindo filtragem para evitar entradas duplicadas. Enums de string são objetos mais simples sem mapeamentos reversos, então filtrar por tipo é geralmente suficiente.

Como iterar sobre um enum no TypeScript?

Você pode iterar sobre enums no TypeScript usando uma das seguintes abordagens, dependendo do tipo de enum e de suas necessidades:

Usando métodos de objeto para iterar sobre enums no TypeScript

A maneira mais simples de iterar sobre um enum no TypeScript é convertê-lo em um array usando os métodos incorporados Object.keys() e Object.values(). O primeiro retorna um array contendo as chaves do objeto enum, e o último retorna um array de valores do enum.

O código a seguir mostra como usar o método incorporado de objeto para listar as chaves e os valores de um enum:

const keys = Object.keys(TrafficLight)

keys.forEach((key, index) => {
        console.log(`${key} has index ${index}`)
})

O exemplo acima imprime o seguinte:

"1 has index 0"
"2 has index 1"
"3 has index 2"
"Green has index 3"
"Yellow has index 4"
"Red has index 5"

Veja como as chaves numéricas aparecem primeiro? Isso ocorre porque enums numéricos geram um mapeamento reverso. Se quisermos listar apenas as chaves de string, precisaremos filtrar as numéricas:

const stringKeys = Object
    .keys(TrafficLight)
    .filter((v) => isNaN(Number(v)))

stringKeys.forEach((key, index) => {
    console.log(`${key} has index ${index}`)
})

Neste caso, o snippet acima imprime o seguinte:

"Green has index 0"
"Yellow has index 1"
"Red has index 2"