Como usar enums em TypeScript

Um enum, ou um tipo enumerado, é uma estrutura de dados que permite definir um conjunto de valores nomeados.

Enums fornecem uma maneira de representar um conjunto fixo de valores como constantes. Eles podem ajudar a tornar seu código mais expressivo e autodocumentado, fornecendo nomes significativos para valores específicos. Aqui você aprenderá como usar enums no TypeScript.

Criando um Enum

Enums geralmente representam um número fixo de opções para um determinado valor. Por exemplo, uma enumeração representando cores primárias pode ter valores fixos para vermelho, amarelo e azul.

Enums representam dados como um conjunto de pares de chave/valor conhecidos como membros de enum. A chave deve ser sempre uma string. No entanto, o valor — um número de incremento automático por padrão — pode ser numérico, uma string ou computado.

Você pode criar um enum em a linguagem TypeScript usando o

enumerar palavra-chave. Siga-o com o nome do enum e um par de chaves ({}) contendo os membros da enumeração. Uma convenção de nomenclatura JavaScript comum afirma que os nomes de enumeração devem começar com uma letra maiúscula.

enumerar Direção {
 Acima,
 Abaixo,
 Esquerda,
 Certo
}

Este exemplo apresenta uma enumeração chamada Direção. O enum tem um membro que representa cada direção: Up, Down, Left e Right.

Como esse código não especifica um valor para cada uma das chaves, o TypeScript atribuirá valores automaticamente. O primeiro membro, Up, terá um valor de 0. Os membros restantes terão, cada um, um valor 1 maior que o do membro anterior. Você pode declarar isso explicitamente se achar difícil de lembrar:

enumerar Direção {
 Para cima = 0,
 para baixo = 1,
 Esquerda = 2,
 Direita = 3,
}

Ou você pode declarar explicitamente valores diferentes, deixando valores não declarados para continuar incrementando como antes:

enumerar Status {
 Ativo = 9,
 Inativo, // 10
}

Neste exemplo, o membro inativo tem um valor de 10. Esse comportamento se aplica a enums que possuem apenas valores numéricos, não aqueles com cadeia de caracteres ou membros heterogêneos.

Os Diferentes Tipos de Enum

Enums em TypeScript têm um tipo implícito que se baseiam no tipo de valores que seus membros possuem. O tipo mais comum é a enumeração numérica, cujo comportamento foi abordado na seção anterior, mas há duas variações.

Enumerações de String

Uma enumeração de string é uma enumeração na qual todos os seus membros são strings. Ao contrário de enums numéricos, onde os valores são atribuídos automaticamente, você deve inicializar cada membro com uma string:

enumerar Cores primárias {
 Vermelho = "VERMELHO",
 Amarelo = "AMARELO",
 Azul = "AZUL"
}

Embora as enums de string não tenham propriedades de incremento automático, elas podem fazer mais sentido se você as serializar. Seus valores ainda devem ser descritivos, sem nomes de membros, enquanto um conjunto de valores numéricos pode não ser autodescritivo.

Enums heterogêneos

Enumerações heterogêneas são enumerações que contêm membros numéricos e de cadeia de caracteres. Por exemplo:

enumerar Resultado {
 Sucesso = "SUCESSO",
 Falha = 0
}

Enumerações heterogêneas são úteis quando você tem membros de enumeração que exigem diferentes tipos de valor com base no contexto ou significado específico de cada membro. No entanto, o Documentação do TypeScript desencoraja o uso de enumerações heterogêneas, pois elas introduzem complexidade que pode tornar seu código mais sujeito a erros.

Membros de enumeração computados e constantes

Cada membro da enumeração tem um valor, que pode ser constante ou computado.

Membros de enumeração constante

Um membro de enumeração é constante se satisfizer qualquer uma das condições abaixo.

1. É o primeiro membro da enumeração e não possui inicializador.
2. Ele não tem um inicializador e o membro de enumeração anterior era uma constante numérica.
3. Ele é inicializado com uma expressão de enumeração constante.

De acordo com a documentação do TypeScript, uma expressão de enumeração constante é um subconjunto de expressões do TypeScript que podem ser totalmente avaliadas em tempo de compilação. Por exemplo, uma string ou um literal numérico.

Por exemplo, os membros das enumerações no bloco de código abaixo são todos constantes:

// CASO 1
enumerar Direção {
 Acima,
 Abaixo,
 Esquerda,
 Certo
}
// CASO 2
enumerar Dia da semana {
 segunda-feira = 1,
 Terça-feira,
 Quarta-feira,
 Quinta-feira,
 Sexta-feira
}
// CASO 3
enumerar Temporada {
 Primavera = "PRIMAVERA",
 verão = "VERÃO",
 Outono = "OUTONO",
 inverno = "INVERNO"
}

Ao transpilar membros de enumeração constantes em JavaScript simples, o código gerado usa seus valores literais. Isso pode ser benéfico para o desempenho e facilitar a depuração.

Por exemplo, aqui está a versão transpilada da enumeração Season:

var Temporada;
(função (Temporada) {
 Temporada["Primavera"] = "PRIMAVERA";
 Temporada["Verão"] = "VERÃO";
 Temporada["Outono"] = "OUTONO";
 Temporada["Inverno"] = "INVERNO";
})(Temporada || (Temporada = {}));

Membros de enumeração computados

Você pode usar membros de enumeração calculados para atribuir valores a membros de enumeração com base em expressões ou outros cálculos dinâmicos. Por exemplo:

enumerar Tamanho {
 Pequeno = 1,
 Médio = calcularTamanho(12),
 Grande = calcularTamanho(5)
}
funçãocalcularTamanho(valor: número): número{
retornar valor * 5;
}
console.log (Tamanho. Grande)

O Tamanho enum tem três membros: Pequeno, Médio, e Grande. Ele atribui explicitamente o valor 1 ao membro Small. O Médio e Grande membros usam uma função calcularTamanho para calcular seus valores em tempo de execução.

Ao trabalhar com membros de enumeração computados, é importante observar que os valores não são conhecidos até o tempo de execução. Isso pode introduzir mais complexidade e potencial erros de execução em comparação com membros de enumeração com valores constantes.

Por exemplo:

var Tamanho;
(função (Tamanho) {
 Tamanho[Tamanho["Pequeno"] = 1] = "Pequeno";
 Tamanho[Tamanho["Médio"] = calcularTamanho(12)] = "Médio";
 Tamanho[Tamanho["Grande"] = calcularTamanho(5)] = "Grande";
})(Tamanho || (Tamanho = {}));
console.registro(Tamanho.Grande)

O bloco de código acima é a versão transpilada do Tamanho enum. Observe como o TypeScript não inclui os valores de retorno de calculateSize() no código JavaScript. Em vez disso, inclui a chamada de função original para que o JavaScript determine os valores em tempo de execução.

Acessando Valores Enum

Você pode acessar os valores dos membros da enumeração usando a notação de ponto do objeto.

Por exemplo:

enumerar Direção {
 Para cima = 0,
 para baixo = 1,
 Esquerda = 2,
 Direita = 3,
}
console.log (Direção. Esquerda) // 2

Enums Numéricos de Mapeamento Reverso

O mapeamento reverso em enumerações numéricas refere-se à capacidade de buscar o nome do membro de enumeração correspondente a partir de seu valor. Isso pode ser particularmente útil ao trabalhar com valores numéricos, que podem ser necessários para decodificar.

Por padrão, os valores de enum no TypeScript são mapeados para frente, o que significa que você só pode acessar o valor associado a um nome. No entanto, você pode executar manualmente o mapeamento reverso para recuperar o membro enum com base em seu valor.

Por exemplo:

enumerar Direção {
 Para cima = 1,
 Abaixo,
 Esquerda,
 Certo
}
funçãogetDirectionName(valor da direção: número): corda{
// mapeamento reverso
const direçãoNome = Direção[direçãoValor];
retornar direçãoNome;
}
console.log (getDirectionName(1)); // "Acima"
console.log (getDirectionName(3)); // "Esquerda"

Esse getDirectionName A função executa o mapeamento reverso acessando o nome do membro enum usando seu valor como um índice. A função leva um valor da direção como um argumento e recupera o nome do membro enum correspondente usando Direção[direçãoValor].

O mapeamento reverso pode ser útil em cenários em que você tem um valor numérico e precisa determinar o nome do membro de enumeração correspondente. Ele fornece uma maneira conveniente de trabalhar com enums nas direções direta e reversa.

Existem muitas aplicações de enums

Você pode usar enums em vários cenários, como lidar com instruções switch, definir parâmetros de função, mapear dados e representar opções ou configurações.

Se você precisa representar um conjunto finito de opções ou gerenciar transições de estado complexas, as enumerações no TypeScript são uma ferramenta valiosa para aprimorar a clareza e a estrutura do seu código.