typescript switch on regex

Art Scpae

2 min read

·

24-10-2024

63

0

Share

Switching on Strings with Regular Expressions in TypeScript

TypeScript's switch statement is a powerful tool for handling conditional logic. But what if you want to switch based on patterns within strings, rather than exact matches? That's where regular expressions (regex) come in.

The Problem with Traditional switch

Let's say you have a function that takes a string representing a file extension and needs to perform different actions based on the type. Using a traditional switch might look like this:

function handleFile(extension: string) {
  switch (extension) {
    case ".txt":
      console.log("Handling text file");
      break;
    case ".jpg":
      console.log("Handling image file");
      break;
    case ".pdf":
      console.log("Handling PDF file");
      break;
    default:
      console.log("Unknown file type");
  }
}

handleFile(".txt"); // Outputs: "Handling text file"

This works fine for specific extensions. But what if you want to handle all image files (.jpg, .png, .gif) or all document files (.doc, .docx, .pdf)? You'd need to add a case for each individual extension, making the code longer and less maintainable.

Regular Expressions to the Rescue

Regular expressions (regex) are powerful tools for matching patterns in strings. In TypeScript, we can use regex within switch statements to achieve more flexible matching.

function handleFile(extension: string) {
  const regex = new RegExp(/\.((jpg|png|gif)|(doc|docx|pdf))/);
  const match = regex.exec(extension);

  if (match) {
    switch (match[1]) {
      case "jpg":
      case "png":
      case "gif":
        console.log("Handling image file");
        break;
      case "doc":
      case "docx":
      case "pdf":
        console.log("Handling document file");
        break;
      default:
        console.log("Unknown file type");
    }
  } else {
    console.log("Invalid file extension");
  }
}

handleFile(".jpg"); // Outputs: "Handling image file"
handleFile(".pdf"); // Outputs: "Handling document file"
handleFile(".zip"); // Outputs: "Invalid file extension"

Explanation:

1. We create a regular expression regex to match the desired patterns. In this case, it matches any extension that starts with a dot (.) followed by either "jpg", "png", "gif" or "doc", "docx", "pdf".
2. We use regex.exec(extension) to check if the regex matches the given extension.
3. If a match is found, the switch statement evaluates the value captured in the first capturing group (match[1]) which contains the specific extension type.
4. We can then handle the different types of files using the appropriate cases.
5. If no match is found, we handle the situation accordingly.

Benefits of Using Regex in switch

• Conciseness: Instead of listing each individual extension, you can group them using regex patterns.
• Flexibility: Regex allows for more complex pattern matching, going beyond simple string equality. You can easily handle extensions with varying capitalization, optional characters, and more.
• Maintainability: If you need to add or modify supported file types, you only need to change the regex pattern, making your code easier to update.

Beyond File Extensions

The combination of switch and regex can be applied to various scenarios. For example:

• URL parsing: Switch on different URL segments to handle different routes or API endpoints.
• Data validation: Validate input data formats like email addresses, phone numbers, or dates.
• String processing: Perform different actions based on specific keywords or patterns within a text string.

Conclusion

By leveraging the power of regular expressions within switch statements, you can create more flexible and maintainable TypeScript code for handling strings with patterns. Explore the possibilities and find creative ways to utilize this powerful combination.

Note: This article is based on information and code snippets found on GitHub, but the content has been re-written and expanded with additional explanations and practical examples. This article provides a basic understanding of the topic and should be further explored for a comprehensive grasp.