When working with TypeScript, you might find yourself needing to define a union type and an array containing all of the possible values of that type. A common approach is to write something like this:

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

At first glance, this seems fine. However, there's a hidden problem here: every time you want to change or add an option, you need to update both the Taste union type and the tastes array. This duplication of effort can lead to mistakes and makes maintaining the code more tedious.

Luckily, there's a way to simplify this by reducing redundancy. By using the as const assertion and typeof in TypeScript, you can consolidate the definition of both the union type and the array into one place. Here's how you can refactor the above code:

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

This approach has several benefits:

1. Single Source of Truth:
   
   You only define the list of values once, in the tastes array. The Taste type is automatically derived from this array, so if you ever need to update the list, you only have to do it in one place.

2. Type Safety:
   
   By using as const, TypeScript treats the tastes array as a tuple with literal types instead of just a string array. This ensures that the Taste type remains accurate and aligned with the values in tastes.

3. Better Maintenance:
   
   Since the Taste type is generated from the array, there’s no risk of mismatch between the type and the actual values. This reduces the potential for bugs and makes the code easier to maintain.

Example Use Case

Now, whenever you use the Taste type in your code, it’s guaranteed to match the values in the tastes array:

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!

This pattern not only improves your code’s readability but also ensures that it’s less error-prone, especially when dealing with multiple values that need to be kept in sync.

By embracing this strategy, you can make your TypeScript code more maintainable and scalable. This is particularly useful when you're dealing with large sets of values or when your codebase grows over time.