Regex for Beginners: How to Test Regular Expressions Online

\.

To make a quantifier lazy, add a \?\ after it: \<.*?>\ will match \

\ separately. Lazy quantifiers consume as few characters as possible. Choose greedy when you want the largest match, lazy when you want the smallest.

Testing Regex Online

The fastest way to learn regex is to experiment. Paste your pattern and sample text into our regex tester, and see matches highlighted instantly. Toggle flags like \g\, \i\, and \m\ to understand how they change results. Capture groups appear in a breakdown panel so you can verify exactly what each group matched.

Next Steps

Once you're comfortable with the basics, practice with real-world patterns: email validation, URL extraction, phone number parsing, and log file analysis. The patterns below in the cheat sheet section give you a head start.

Common Regex Patterns Cheat Sheet

Save this table — these patterns cover 80% of real-world regex use cases:

Important: These patterns are starting points, not production-ready validators. For email, consider using a dedicated validation library rather than regex — the RFC 5322 specification for valid email addresses is too complex for any practical regex.

Regex Performance Optimization

Badly written regex can cause catastrophic backtracking — where the engine takes exponential time on certain inputs. This has taken down production systems (the 2016 Stack Overflow outage was caused by one regex).

How to Detect Slow Regex

\\\`javascript

// Test regex performance

const start = performance.now();

'aaaaaaaaaaaaaaaaaaaaab'.match(/^(a+)+$/);

const elapsed = performance.now() - start;

console.log(\Took \${elapsed}ms\); // Can take 10+ seconds!

\\\`

If a regex takes more than a few milliseconds on a short string, you have catastrophic backtracking.

Optimization Techniques

1. Be specific instead of broad. Replace \.*\ with \[^<]*\ when matching HTML content — it prevents the engine from backtracking across the entire string.

2. Use possessive quantifiers or atomic groups. JavaScript doesn't support possessive quantifiers (\a++\), but you can use atomic groups via the \v\ flag in modern engines. In Python, use \re.ASCII\ and atomic patterns.

3. Anchor your patterns. \^\\d{4}\ is faster than \\\d{4}\ because the engine doesn't scan the entire string if the match must be at the start.

4. Avoid nested quantifiers. Patterns like \(a+)+\ or \(a*)*\ are the primary cause of catastrophic backtracking. Flatten them whenever possible.

5. Compile once, use many times. In Python, use \re.compile()\ to pre-compile patterns. In JavaScript, define regex literals outside loops:

\\\`python

# Compile once at module level

EMAIL_RE = re.compile(r'^[\\w.+-]+@[\\w-]+\\.[a-zA-Z]{2,}$')

def is_valid_email(email):

return bool(EMAIL_RE.match(email)) # Fast — no recompilation

\\\`

Debugging Regex Effectively

When a regex doesn't match what you expect, follow this systematic approach:

Step 1 — Simplify. Remove quantifiers and groups one at a time until the pattern matches. Then add them back one by one to find the failing component.

Step 2 — Use an interactive tester. Our regex tester highlights each capture group separately, so you can see exactly which part of your pattern is consuming which text.

Step 3 — Check for hidden characters. Copy-pasted text often contains invisible characters: zero-width spaces (U+200B), non-breaking spaces (U+00A0), or carriage returns. Use \[\\s\\S]\ instead of \.\ if you suspect newlines are the issue.

Step 4 — Verify flags. A pattern that works without the \g\ flag can behave differently with it — especially in JavaScript's \String.match()\ vs \String.matchAll()\.

Comparison: Regex Engines

Different environments use different regex engines, and behavior varies:

Key gotcha: Go's RE2 engine does not support backreferences (\\\1\) or lookarounds (\(?=...)\). This is a deliberate design choice to guarantee O(n) performance — no catastrophic backtracking is possible. If you're porting regex from another language to Go, you may need to rewrite patterns.\