Regex Tester

. matches any single character except newline (unless s flag). \d matches any digit [0–9]. \w matches a word character [a–zA–Z0–9_]. \s matches any whitespace character (space, tab, newline, carriage return). Their uppercase counterparts (\D, \W, \S) match the inverse — any non-digit, non-word, or non-whitespace character respectively.

A capture group is a portion of a regex enclosed in parentheses () that captures the matched substring for later use. Groups are numbered from 1 left to right. Example: (\d{4})-(\d{2})-(\d{2}) on "2024-01-15" captures "2024" in group 1, "01" in group 2, "15" in group 3. Named groups use (?<name>pattern) syntax. Non-capturing groups use (?:pattern) to group without capturing.

Greedy quantifiers (*, +, ?, {n,m}) match as much as possible. <.+> on <a> and <b> matches the entire <a> and <b>. Lazy (reluctant) quantifiers (*?, +?, ??, {n,m}?) match as little as possible. <.+?> on the same input matches only <a>. Use lazy quantifiers when you need to match the shortest possible string between delimiters.

Lookahead ((?=...)) asserts what comes after the current position without consuming characters. Example: \w+(?=\s+is) matches the word before "is". Negative lookahead ((?!...)) asserts that a pattern does NOT follow. Lookbehind ((?<=...)) asserts what comes before. Negative lookbehind ((?<!...)) asserts what does not come before. Lookbehind is supported in modern JavaScript (ES2018+) but not in older environments.

\b is a zero-width assertion that matches the position between a word character (\w) and a non-word character. It does not consume any characters. \bword\b matches the whole word "word" but not "password" or "wording". Use it to match complete words: \bcat\b matches "cat" in "the cat sat" but not in "concatenate".

Escape the special character with a backslash \. The special characters that need escaping in regex are: . * + ? ^ $ { } [ ] | ( ) \. Example: to match a literal period, use \. instead of .. To match a literal dollar sign, use \$. When building regex from user input in code, use a function to escape all special characters: str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').

Catastrophic backtracking (ReDoS) occurs when a regex with nested quantifiers takes exponential time to fail. Example: (a+)+b against a long string of "a"s with no "b" — the engine tries an exponential number of grouping combinations before giving up. Mitigation: avoid nested quantifiers with overlapping possibilities, use atomic groups or possessive quantifiers where available, and validate user-supplied regex patterns before applying them to untrusted input. Use this tester to measure performance before production use.

JavaScript regex (ECMAScript) lacks some features found in PCRE and Python: no recursive patterns, no conditional patterns, no branch reset groups, no possessive quantifiers (though atomic groups were added in ES2022 via (?>...)). JavaScript added named capture groups ((?<name>)), lookbehind, and s (dotAll) flag in ES2018. JavaScript's u flag enables full Unicode mode. This tester uses JavaScript regex — patterns from other flavors may behave differently.

Use the m (multiline) flag to make ^ and $ match the start and end of each line. Use the g (global) flag with String.matchAll() to find all occurrences across lines. To match content spanning multiple lines, use the s (dotAll) flag to make . match newlines, or use [\s\S] as a universally compatible alternative. Example: /^start[\s\S]*?end$/m matches from "start" to "end" across lines.