Regex Pattern Prompt Templates

## US Phone Number Regex

```javascript
const phoneRegex = /^\(?([0-9]{3})\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$/;
```

### Component Breakdown

| Component | Meaning |
|-----------|--------|
| `^` | Start of string |
| `\(?` | Optional opening parenthesis |
| `([0-9]{3})` | **Group 1:** Area code (exactly 3 digits) |
| `\)?` | Optional closing parenthesis |
| `[-. ]?` | Optional separator (hyphen, dot, or space) |
| `([0-9]{3})` | **Group 2:** Exchange (exactly 3 digits) |
| `[-. ]?` | Optional separator |
| `([0-9]{4})` | **Group 3:** Subscriber (exactly 4 digits) |
| `$` | End of string |

### Usage

```javascript
const phoneRegex = /^\(?([0-9]{3})\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$/;

// Test matching
phoneRegex.test('(555) 123-4567'); // true
phoneRegex.test('555-123-4567'); // true
phoneRegex.test('5551234567'); // true

// Extract groups
const match = '(555) 123-4567'.match(phoneRegex);
// match[1] = '555' (area code)
// match[2] = '123' (exchange)
// match[3] = '4567' (subscriber)
```

### Test Cases

```javascript
// Should match
✓ '(555) 123-4567' // Parentheses with space and hyphen
✓ '555-123-4567' // Hyphens only
✓ '555.123.4567' // Dots only
✓ '555 123 4567' // Spaces only
✓ '5551234567' // No separators
✓ '(555)123-4567' // Parentheses, no space

// Should NOT match
✗ '123-4567' // Missing area code (only 7 digits)
✗ '55-123-4567' // Area code too short
✗ '5555-123-4567' // Area code too long
✗ '555-1234-567' // Wrong grouping
✗ '555-123-45678' // Subscriber too long
✗ '+1 555-123-4567' // Has country code (not handled)
✗ '555) 123-4567' // Mismatched parenthesis
```

### Caveats

1. **Doesn't validate real numbers:** `000-000-0000` matches but isn't valid
2. **No country code:** Add `(?:\+1[-. ]?)?` at start if needed
3. **Mismatched parens:** `555) 123-4567` currently matches; tighten if needed:
 ```javascript
 /^(?:\(([0-9]{3})\)|([0-9]{3}))[-. ]?([0-9]{3})[-. ]?([0-9]{4})$/
 ```
4. **Extensions not supported:** Add `(?:\s*(?:ext|x)\.?\s*([0-9]+))?$` for extensions

## Regex Debug Analysis

### Problems Identified

1. **Case sensitivity:** Pattern only allows lowercase `[a-z]`
2. **No dots in local part:** `.` before `@` not allowed
3. **Single-part domain:** No subdomains (`.co.uk`) allowed
4. **TLD length limited:** `{2,3}` excludes `.info`, `.museum`, etc.
5. **Too permissive:** No length minimums, `a@b.cc` matches

### Fixed Pattern

```javascript
const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/i;
```

### What Changed

| Original | Fixed | Why |
|----------|-------|-----|
| `[a-z]+` | `[a-zA-Z0-9._%+-]+` | Allow common email characters |
| `@[a-z]+` | `@[a-zA-Z0-9.-]+` | Allow subdomains (mail.company) |
| `\.[a-z]{2,3}` | `\.[a-zA-Z]{2,}` | Allow any TLD length |
| No flag | `i` flag | Case insensitive |

### Even Better: More Solid Pattern

```javascript
// Handles more edge cases
const robustEmailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
```

This is simpler and catches most valid emails:
- `[^\s@]+` = anything except whitespace and @
- Allows unicode characters in local part
- Less prone to false negatives

### Test Results

```javascript
const fixed = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/i;

// Now matches:
✓ 'John@Example.COM' // Uppercase handled
✓ 'user.name@company.co.uk' // Dots and subdomains
✓ 'test@example.info' // Long TLD

// Still correctly rejects:
✗ 'missing@tld' // No TLD
✗ '@nodomain.com' // No local part
✗ 'spaces not@allowed.com' // Has spaces
```

### Caveat

No regex perfectly validates email addresses (the RFC is complex). For production:
1. Use a library (validator.js, email-validator)
2. Or just check for `@` and send a confirmation email

## Catastrophic Backtracking Analysis

### The Problem

Your pattern `/^(a+)+$/` has **catastrophic backtracking**, a common regex performance trap.

### Why It's Slow

```
Pattern: /^(a+)+$/
Input: 'aaaaaaaaaaaaaaab' (15 a's + b)
```

**What happens:**
1. `(a+)` matches all 15 a's
2. `$` fails (there's a 'b')
3. Regex backtracks, tries `(a+)` with 14 a's
4. Inner `(a+)+` tries to match remaining 'a'
5. Fails, backtracks again
6. This creates **2^n combinations** to try

For 30 characters: 2^30 = 1 billion+ attempts

### Visualization

```
(a+)+$ matching 'aaab':

Attempt 1: (aaa) → fail at b
Attempt 2: (aa)(a) → fail at b 
Attempt 3: (aa) → fail (need more a's for +)
Attempt 4: (a)(aa) → fail at b
Attempt 5: (a)(a)(a) → fail at b
Attempt 6: (a)(a) → fail
Attempt 7: (a) → fail
... exponential explosion
```

### The Fix

**Option 1: Possessive quantifier (if supported)**
```javascript
// Not in JavaScript, but in Java/PCRE:
/^(a++)+$/ // ++ means "don't backtrack"
```

**Option 2: Atomic group (if supported)**
```javascript
// Not in JavaScript:
/^(?>a+)+$/ // Atomic: no backtracking into group
```

**Option 3: Simplify (JavaScript solution)**
```javascript
// If you just want "one or more a's":
/^a+$/

// If you need the groups for some reason:
/^(a)+$/ // Each 'a' is a group
```

**Option 4: Use non-regex**
```javascript
// For simple patterns, string methods are faster:
function isAllAs(str) {
 return str.length > 0 && !str.includes('b') && /^a+$/.test(str);
 // Or even:
 return str.length > 0 && [...str].every(c => c === 'a');
}
```

### Avoiding Catastrophic Backtracking

**Red flags in patterns:**
- Nested quantifiers: `(a+)+`, `(a*)*`, `(a+)*`
- Adjacent overlapping: `(a+)(a+)` or `.*.*`
- Alternation with overlap: `(a|aa)+`

**Safe alternatives:**
```javascript
// Instead of: (a+)+
// Use: a+

// Instead of:.*.*
// Use:.*

// Instead of: (a|aa)+
// Use: a+
```

### Performance Comparison

```
Input: 'a'.repeat(25) + 'b'

/^(a+)+$/: >30 seconds (hangs)
/^a+$/: <1ms
```

### Testing for Catastrophic Backtracking

```javascript
function testRegexPerformance(regex, input) {
 const start = performance.now();
 regex.test(input);
 const time = performance.now() - start;
 console.log(`${time.toFixed(2)}ms`);
}

// Test with increasing lengths
for (let i = 15; i <= 30; i += 5) {
 const input = 'a'.repeat(i) + 'b';
 console.log(`Length ${i}:`);
 testRegexPerformance(/^(a+)+$/, input); // Dangerous
 testRegexPerformance(/^a+$/, input); // Safe
}
```

## Console.log Removal Regex

### VS Code Find/Replace

**Find:**
```
^(?!\s*//).*console\.log\([^)]*\);?\s*$
```

**Replace:**
```
(empty - just delete)
```

**Settings:** Enable "Use Regular Expression" (Alt+R)

### Pattern Breakdown

| Component | Meaning |
|-----------|--------|
| `^` | Start of line |
| `(?!\s*//)` | Negative lookahead: NOT followed by optional whitespace and `//` |
| `.*` | Any characters before console.log |
| `console\.log\(` | Literal `console.log(` |
| `[^)]*` | Any characters except `)` (the arguments) |
| `\)` | Closing parenthesis |
| `;?` | Optional semicolon |
| `\s*$` | Optional trailing whitespace to end of line |

### Handling Nested Parentheses

The simple pattern above fails on:
```javascript
console.log(fn(a, b)); // Has nested parens
```

**More solid pattern:**
```
console\.log\((?:[^)(]+|\((?:[^)(]+|\([^)(]*\))*\))*\);?
```

Or use a multi-pass approach:

### Safer: Multiple Passes

**Pass 1 - Simple logs:**
```
Find: console\.log\([^)]*\);?\n?
Replace: (empty)
```

**Pass 2 - Single nested:**
```
Find: console\.log\([^)]*\([^)]*\)[^)]*\);?\n?
Replace: (empty)
```

**Pass 3 - Manual review:**
Search for remaining `console.log` and handle manually.

### JavaScript Alternative

For a build tool, use an AST-based approach instead:

```javascript
// babel-plugin-transform-remove-console
// In babel.config.js:
module.exports = {
 plugins: [
 ['transform-remove-console', { exclude: ['error', 'warn'] }]
 ]
};
```

### Edge Cases

| Input | Handled? |
|-------|----------|
| `console.log('test');` | ✓ Removed |
| `console.log(a, b, c)` | ✓ Removed |
| `// console.log()` | ✓ Kept (commented) |
| `console.log(fn())` | ⚠️ Simple pattern fails |
| `console.log(\`template\`)` | ⚠️ May fail on backticks |
| Multi-line console.log | ✗ Not handled |

### Recommendation

For production code removal:
1. Use the Babel plugin (safest)
2. Or use ESLint with `no-console` rule + `--fix`
3. Regex is good for quick cleanup but review the diff