Regex Tester

How Regular Expressions Work

A regular expression (regex) is a sequence of characters that defines a search pattern. The JavaScript regex engine processes patterns using a state machine — it advances through the input string character by character, attempting to match the pattern at each position. When it finds a match, it records the position and (if using the global flag) continues searching from the end of that match.

Modern JavaScript regexes support the full ECMAScript specification including named capture groups ((?<name>...)), Unicode property escapes (\p{Letter} with the u flag), lookbehind assertions, and the d flag for match indices. All matching in this tool runs in your browser using the built-in JavaScript RegExp engine.

Regex Flags Explained

• g (global) — Find all matches in the string, not just the first. Without this flag, exec() and match() return only the first match.
• i (case-insensitive) — Match regardless of case. /hello/i matches "hello", "Hello", "HELLO".
• m (multiline) — ^ and $ match the start and end of each line, not just the full string. Essential for line-by-line matching.
• s (dotAll) — Makes . match any character including newline (\n). Without this flag, . does not match line breaks.

Capture Groups vs Non-Capturing Groups

A capturing group (abc) records the matched substring and makes it available as a numbered back-reference ($1, $2) or in the match array. Use capturing groups when you need to extract specific parts of a match.

A non-capturing group (?:abc) groups part of a pattern without creating a reference. This is more efficient when you only need the grouping behavior for quantifiers or alternation, not the captured value.

// Capturing — $1 = area code
const phone = '(415) 555-1234'.match(/\((\d{3})\)\s(\d{3}-\d{4})/);
// phone[1] = '415', phone[2] = '555-1234'

// Non-capturing — just grouping for the quantifier
const date = '2026-05-28'.match(/(?:\d{4})-(\d{2})-(\d{2})/);
// date[1] = '05', date[2] = '28' (year not captured)

Lookahead and Lookbehind

Lookaround assertions match positions in the string without consuming characters. They are zero-width — they test that a condition is (or is not) true at the current position, then let the rest of the pattern match from that same position.

// Positive lookahead: match word only if followed by a digit
/\w+(?=\d)/.exec('foo3 bar baz2')  // 'foo', 'baz'

// Negative lookahead: match word NOT followed by a digit
/\w+(?!\d)\b/.exec('foo3 bar')     // 'bar'

// Positive lookbehind: match digits preceded by '$'
/(?<=\$)\d+/.exec('price $42')    // '42'

Catastrophic Backtracking

Catastrophic backtracking occurs when a regex with nested quantifiers and ambiguous patterns is applied to a string that almost-but-not-quite matches. The engine explores an exponential number of combinations. The classic example is (a+)+ on the string "aaaaaab" — the engine tries every possible grouping before concluding no match.

To avoid it: use possessive quantifiers or atomic groups where available, prefer specific character classes over .*, and test patterns on long near-miss strings before deploying to production. Regular expression denial-of-service (ReDoS) is a real security vulnerability that has affected Node.js applications and web servers.