Utilizando Enumerações (Enum) - TypeScript

O tipo enum ou enumeração permite definir um conjunto de constantes nomeadas que descrevem certos estados.

Para definir uma enumeração, utiliza-se a palavra-chave enum. Por exemplo, vamos declarar a seguinte enumeração:

Agora, vamos usar a enumeração:

enum Season { Winter, Spring, Summer, Autumn };
let current: Season = Season.Summer;
console.log(current);       // 2
current = Season.Autumn;    // alterando o valor

Aqui, criamos a variável current, que tem o tipo Season. O console do navegador exibirá o número 2: o valor da constante Season.Summer.

Enumerações numéricas

Por padrão, as constantes da enumeração representam valores numéricos. Ou seja, é uma enumeração numérica em que cada constante é associada a um valor numérico.

A enumeração criada acima:

É, na verdade, equivalente a:

Podemos redefinir explicitamente esses valores. Se atribuirmos um valor a uma constante, os valores das constantes seguintes serão incrementados em um:

Ou podemos atribuir um valor específico a cada constante:

Também podemos obter diretamente o valor textual:

enum Season { Winter = 0, Spring = 1, Summer = 2, Autumn = 3 };
var current: string = Season[2];  // Summer
console.log(current);             // Summer

Enumerações de strings

Além das enumerações numéricas, o TypeScript possui enumerações de strings, cujas constantes assumem valores textuais:

enum Season { 
  Winter = "Inverno", 
  Spring = "Primavera",
  Summer = "Verão", 
  Autumn = "Outono"
};
var current: Season = Season.Summer;
console.log(current);   // Verão

Enumerações heterogêneas mistas

Também é possível definir enumerações mistas, cujas constantes podem ser números e strings.

enum Season { 
  Winter = 1, 
  Spring = "Primavera",
  Summer = 3, 
  Autumn = "Outono"
};
var current: Season = Season.Summer;
console.log(current);           // 3
console.log(Season.Autumn);     // Outono

Enumerações em funções

A enumeração pode ser usada como parâmetro de função.

enum DayTime { 
  Morning, 
  Evening
};
function welcome(dayTime: DayTime) {
  if(dayTime === DayTime.Morning) {
      console.log("Bom dia");
  } else {
      console.log("Boa noite");
  }
}
let current: DayTime = DayTime.Morning;
welcome(current);           // Bom dia
welcome(DayTime.Evening);   // Boa noite

Cada constante da enumeração descreve um certo estado. A função welcome() recebe esse estado como parâmetro dayTime e, dependendo do valor recebido, exibe uma mensagem específica no console.

No entanto, é importante notar que, como a enumeração DayTime é numérica, podemos passar valores numéricos para a função welcome():

Ou até mesmo definir o parâmetro da função como numérico e passar constantes da enumeração numérica:

enum DayTime { 
  Morning, 
  Evening
};
function welcome(dayTime: number) {
  if(dayTime === DayTime.Morning) {
      console.log("Bom dia");
  } else {
      console.log("Boa noite");
  }
}
let current: DayTime = DayTime.Morning;
welcome(current);           // Bom dia
welcome(DayTime.Evening);   // Boa noite

Exemplo com parâmetro de enumeração de strings:

enum DayTimeMessage { 
  Morning = "Bom dia", 
  Evening = "Boa noite"
};
function welcome(message: DayTimeMessage) {
  console.log(message);
}
let mes: DayTimeMessage = DayTimeMessage.Morning;
welcome(mes);                      // Bom dia
welcome(DayTimeMessage.Evening);   // Boa noite

Ao usar enumerações de strings, ao contrário das numéricas, não podemos passar uma string arbitrária ao parâmetro:

Nesse caso, o compilador nos retornará um erro durante a compilação.

Por outro lado, se o parâmetro for do tipo string, podemos passar tanto strings quanto constantes da enumeração de strings:

enum DayTimeMessage { 
  Morning = "Bom dia", 
  Evening = "Boa noite"
};
function welcome(message: string) {
  console.log(message);
}
let mes: DayTimeMessage = DayTimeMessage.Morning;
welcome(mes);                      // Bom dia
welcome(DayTimeMessage.Evening);   // Boa noite