Ao trabalhar com TypeScript, você pode precisar definir um tipo de união e uma matriz contendo todos os valores possíveis desse tipo. Uma abordagem comum é escrever algo assim:

type Taste = 'しょうゆ' | 'みそ' | 'とんこつ';
const tastes = ['しょうゆ', 'みそ', 'とんこつ'];

À primeira vista, isso parece bom. No entanto, há um problema oculto aqui: toda vez que você quiser alterar ou adicionar uma opção, será necessário atualizar o tipo de união Taste e o array tastes. Essa duplicação de esforços pode levar a erros e tornar a manutenção do código mais tediosa.

Felizmente, há uma maneira de simplificar isso reduzindo a redundância. Usando a afirmação as const e typeof no TypeScript, você pode consolidar a definição do tipo de união e da matriz em um só lugar. Veja como você pode refatorar o código acima:

const tastes = ['しょうゆ', 'みそ', 'とんこつ'] as const;
type Taste = (typeof tastes)[number];

Essa abordagem tem vários benefícios:

1. Fonte única da verdade:
   
   Você define a lista de valores apenas uma vez, no array tastes. O tipo Taste é derivado automaticamente desse array, portanto, se você precisar atualizar a lista, basta fazê-lo em um só lugar.

2. Tipo Segurança:
   
   Ao usar as const, o TypeScript trata o array tastes como uma tupla com tipos literais em vez de apenas um array de strings. Isso garante que o tipo de Sabor permaneça preciso e alinhado com os valores dos gostos.

3. Melhor manutenção:
   
   Como o tipo Taste é gerado a partir do array, não há risco de incompatibilidade entre o tipo e os valores reais. Isso reduz o potencial de bugs e torna o código mais fácil de manter.

Exemplo de caso de uso

Agora, sempre que você usar o tipo Taste em seu código, é garantido que ele corresponda aos valores na matriz tastes:

function describeTaste(taste: Taste): string {
  switch (taste) {
    case 'しょうゆ':
      return 'Savory soy sauce flavor.';
    case 'みそ':
      return 'Rich miso flavor.';
    case 'とんこつ':
      return 'Creamy pork broth flavor.';
    default:
      return 'Unknown taste';
  }
}

const allTastes: Taste[] = tastes; // Safe, because they match the type!

Esse padrão não apenas melhora a legibilidade do seu código, mas também garante que ele seja menos sujeito a erros, especialmente ao lidar com vários valores que precisam ser mantidos sincronizados.

Ao adotar essa estratégia, você pode tornar seu código TypeScript mais sustentável e escalonável. Isso é particularmente útil quando você lida com grandes conjuntos de valores ou quando sua base de código cresce com o tempo.