Regex Builder

You are a regex expert. The user wants to build, test, and validate regular expressions with immediate feedback.

What to check first

• Open a terminal or Node.js REPL to test regex patterns in real time
• Have sample input data ready that matches and doesn't match your intended pattern
• Identify the regex flavor you're targeting (JavaScript, Python, PCRE, etc.) — JavaScript is assumed here

Steps

1. Define what you want to match: email addresses, phone numbers, URLs, specific formats, etc.
2. Start with a simple pattern and test it against sample strings using .test() or .exec()
3. Use character classes [a-z], quantifiers +, *, ?, {n,m}, and anchors ^, $ to refine the pattern
4. Add capturing groups () if you need to extract parts of the matched string
5. Test edge cases: empty strings, special characters, Unicode, boundaries with \b, \B
6. Use alternation | for multiple acceptable patterns (email domains, file extensions)
7. Apply flags: g for global, i for case-insensitive, m for multiline, s for dotall
8. Escape special characters with \ when matching literal dots, parentheses, brackets, etc.

Code

// Regex Builder & Tester
class RegexBuilder {
  constructor() {
    this.pattern = '';
    this.flags = '';
    this.testResults = [];
  }

  // Set the pattern and flags
  setPattern(pattern, flags = '') {
    this.pattern = pattern;
    this.flags = flags;
    return this;
  }

  // Test single string against pattern
  test(input) {
    try {
      const regex = new RegExp(this.pattern, this.flags);
      const result = regex.test(input);
      this.testResults.push({ input, result, match: null });
      return result;
    } catch (e) {
      console.error('Invalid regex:', e.message);
      return false;
    }
  }

  // Extract matches with details
  exec(input) {
    try {
      const regex = new RegExp(this.pattern, this.flags);
      let match;
      const matches = [];
      
      if (this.flags.includes('g')) {
        while ((match = regex.exec(input)) !== null) {
          matches.push({
            full: match[0],
            groups: match.slice(1),
            index: match.index
          });
        }
      } else {
        match = regex.exec(input);
        if (match) {
          matches.push({
            full: match[0],
            groups: match.slice(1),
            index: match.index
          });
        }
      }
      return matches;
    } catch (e) {
      console.error('Regex error

Note: this example was truncated in the source. See the GitHub repo for the latest full version.

Common Pitfalls

• Treating this skill as a one-shot solution — most workflows need iteration and verification
• Skipping the verification steps — you don't know it worked until you measure
• Applying this skill without understanding the underlying problem — read the related docs first

When NOT to Use This Skill

• When a simpler manual approach would take less than 10 minutes
• On critical production systems without testing in staging first
• When you don't have permission or authorization to make these changes

How to Verify It Worked

• Run the verification steps documented above
• Compare the output against your expected baseline
• Check logs for any warnings or errors — silent failures are the worst kind

Production Considerations

• Test in staging before deploying to production
• Have a rollback plan — every change should be reversible
• Monitor the affected systems for at least 24 hours after the change