Have you ever found yourself tangled in a web of if/else statements or a bulky switch case just to map product IDs to their corresponding credits?

I know I have, and while these approaches work, they can become messy and hard to maintain as the number of products grows. Today, I want to share a simple but effective alternative: type-safe dictionaries.

Problem

Let's say you have an online store with various products, each with a unique ID and associated credit value. You need to write code to retrieve the credit amount for a given product ID.

Here's how you might do it with traditional conditional statements:

function getCredits(productId: string): number {
  if (productId === "prod_A123") {
    return 100;
  } else if (productId === "prod_B456") {
    return 200;
  } else if (productId === "prod_C789") {
    return 300;
  } else {
    return 0;
  }
}

This approach works, but imagine adding more products – the code becomes long, repetitive, and difficult to modify.

Solution: A type-safe dictionary!

Instead of tangled conditionals, harness the power of type-safe dictionaries. Think of them as organized maps, where each product ID (a string) serves as the key and its credit value (a number) as the corresponding value.

Here's the magic:

// 1. Define the interface
interface ProductCredits {
  [key: string]: number;
}

// 2. Initiate the dictionary
const productCredits: ProductCredits = {
  prod_A123: 100,
  prod_B456: 200,
  prod_C789: 300,
};

// 3. Write a function to get the data returned
function getCredits(productId: string): number {
  return productCredits[productId] || 0;
}

This approach is cleaner and more type-safe. This updated getCredits function retrieves the credit value directly from the dictionary using the product ID as the key.

If the ID is not found, it returns a default value of 0.

Benefits

• Readability: Crystal-clear code, even for someone new to the logic.
• Maintainability: Adding new products involves updating the dictionary, not complex conditionals.
• Type-Safety: TypeScript ensures correct data types, preventing errors.
• Efficiency: Dictionary lookups are generally faster than conditional chains.

Beyond the Basics

This is just the tip of the iceberg. Customize your solution further by:

• Adding comments to dictionary entries for clarity.
• Using a more structured data source like a database for larger datasets.
• Improve error handling for invalid product IDs.

Closing Thoughts

Type-safe dictionaries offer a powerful alternative to conditional statements for managing product IDs and credits in TypeScript. This approach promotes code readability, maintainability, type-safety, and performance.

So, the next time you face a similar challenge, remember: tame the TypeScript jungle with the elegance of type-safe dictionaries!