Regex Tester

The Regex Tester is a free online tool to build, test, and debug regular expressions with live matching, syntax highlighting, and detailed explanations of what each part of your pattern does. Paste any text and any regex pattern — matches are highlighted instantly, capture groups are extracted, and the tool explains in plain English what your pattern means. Supports the JavaScript regex engine natively (same as RegExp in Node.js and browsers) with compatibility notes for PCRE (PHP, Perl), Python re, Go regexp, and .NET Regex.

Regular expressions are the Swiss Army knife of text processing: validate email addresses, extract URLs from documents, parse log files, rewrite strings, search code, and transform data. But they are notoriously hard to read and easy to get wrong. This regex tester shortens the feedback loop — instead of writing a regex, running your code, seeing it fail, and editing blindly, you iterate in real time, see exactly what matches, inspect capture groups, and understand the pattern. It runs entirely in your browser — your patterns and test strings never leave your device.

A regular expression (regex, regexp) is a pattern that describes a set of strings. Regex engines scan a target string and find all positions where the pattern matches. Every programming language ships with a regex engine — they share a common core of syntax but differ in advanced features (lookbehind, named groups, recursion).

This tester uses the JavaScript regex engine — the same engine that runs in browsers and Node.js. JavaScript regex is based on ECMAScript (specifically ES2018 added lookbehind, named groups, and Unicode property escapes). For patterns that need features from other flavors (like PCRE recursion or .NET balancing groups), use a flavor-specific tester in that language.

Regex core syntax (works everywhere):

``
Literal characters a, b, 1, @ matches those characters
Dot . matches any character except newline
Character class [abc] [a-z] [^0-9] matches any (or none) listed
Anchors ^ $ \b \B start, end, word boundary, non-boundary
Quantifiers ? * + {n} {n,m} 0-1, 0+, 1+, exactly n, n-to-m
Alternation cat|dog matches cat or dog
Groups (abc) captures 'abc'
Non-capturing group (?:abc) groups without capturing
Backreferences \1 \2 refer to earlier capture
Escape special \. \* \? match literal . * ? etc.
``

Flags (modifiers):

``
g global — find all matches (not just first)
i case-insensitive
m multiline — ^ and $ match line starts/ends, not just string start/end
s dotall — . matches newline too
u unicode — treat pattern as Unicode code points
y sticky — match from lastIndex only
``

Advanced features (ES2018+):

``
Lookahead (?=x) — position followed by x
Negative ahead (?!x) — position NOT followed by x
Lookbehind (?<=x) — position preceded by x
Negative behind (?<!x) — position NOT preceded by x
Named groups (?<name>x) — reference later with \k<name>
Unicode prop \p{Letter} — match any Unicode letter (requires u flag)
``

Performance notes: Some patterns can cause catastrophic backtracking — exponential runtime on certain inputs. Classic example: (a+)+$ applied to aaaaaaaaaaX. Avoid nested quantifiers and overlapping alternation. Modern engines (V8, Rust regex) have linear-time matchers that refuse such patterns or handle them safely.

JavaScript regex vs PCRE (PHP, Perl): JavaScript lacks some PCRE features like recursion, possessive quantifiers, atomic groups, (?P<name>...) syntax (though modern JS uses (?<name>...)), and conditional patterns (?(1)yes|no). JavaScript is simpler but sufficient for 99% of use cases.

JavaScript regex vs Python re: Very similar. Python uses (?P<name>...) for named groups (JavaScript uses (?<name>...) since ES2018). Python has re.VERBOSE mode allowing whitespace and comments in the pattern, which JavaScript lacks. Both support lookahead and lookbehind.

JavaScript regex vs Go regexp: Go uses RE2, which guarantees linear time (no catastrophic backtracking). But Go does not support lookahead, lookbehind, or backreferences — features that cannot be implemented in linear time. Go's regex is safer but less powerful.

JavaScript regex vs .NET Regex: .NET supports balancing groups (for matching nested constructs), more built-in character classes, and named groups with (?<name>...). Otherwise similar to JavaScript.

JavaScript regex vs grep: BSD grep uses basic POSIX regex (limited — no ?, +, | without -E). GNU grep with -E (extended) or -P (PCRE) gives you modern features. Ripgrep uses Rust's regex crate, similar to Go RE2 — linear time, no lookbehind.

Regex vs string methods: For simple operations (startsWith, endsWith, includes, split by fixed string), string methods are faster and more readable. Use regex when you need pattern matching — variable content, multiple alternatives, or capture groups.