Regex Tester

How to use the regex tester

1. Enter your pattern between the slashes at the top. Flags (g, i, m, s, u, y) go in the second input.
2. Type or paste a test string on the left. Matches highlight live.
3. Inspect capture groups in the "Matches with groups" list: $0 is the whole match, $1+ are the groups.
4. Use the Replace input to preview a substitution. Supports $1, $2, and $&.
5. Dropdown presets give you a starting pattern for email, URL, IPv4, UUID, ISO date, phone, hex color.

JavaScript regex flags: what they do

• g: global. Find all matches, not just the first. Required for most tools to work usefully.
• i: case-insensitive.
• m: multiline. ^ and $ match at line boundaries, not just string boundaries.
• s: dotall. . matches newlines (off by default).
• u: Unicode mode. Fixes surrogate-pair handling, enables \\p{...} property classes.
• y: sticky. Match only at lastIndex; useful in lexers.

Catastrophic backtracking: the regex that kills your server

Patterns like (a+)+b can blow up exponentially on input like aaaaaaaaaaaaaaaaaaaaaaaaaaX. The engine tries every split of the as before giving up. One user-submitted regex on your server is a denial-of-service away.

Defenses:

• Avoid nested quantifiers on overlapping character classes.
• Use possessive quantifiers or atomic groups (not in JavaScript: use (?=(X))\\1 idiom).
• Never run untrusted user regexes on your server without a timeout.

Named capture groups

Use (?<name>...) to name a group. Access in replacement with $<name> and in code via match.groups.name. Much more maintainable than numeric groups once you have more than two.

Common regex patterns reference

Lookahead and lookbehind

Lookarounds match a position without consuming characters, they're zero-width assertions. JavaScript supports all four types:

• Positive lookahead (?=...): match only if followed by the pattern. \d+(?= dollars) matches the number in 100 dollars but not in 100 euros.
• Negative lookahead (?!...): match only if NOT followed by the pattern. \bfoo(?!bar)\b matches foo alone but not in foobar.
• Positive lookbehind (?<=...): match only if preceded by the pattern. (?<=\$)\d+ matches the digits in $99 but not in 99 alone. Supported in all modern browsers (ES2018+).
• Negative lookbehind (?<!...): match only if NOT preceded by the pattern. (?<!\d)\d{4} matches a 4-digit number not preceded by another digit.

A common use: extract values without the surrounding delimiter, (?<="title":")[^"]+ pulls the title string value from a JSON fragment.

Quantifiers quick reference

Greedy quantifiers expand as far as possible and then backtrack. Lazy quantifiers (? suffix) shrink to the minimum possible match. When parsing HTML-like structures, lazy is almost always what you want.

Regex performance tips

• Anchor with ^ and $: if you only want to match the full string, anchoring eliminates most backtracking. ^\d+$ is far faster than \d+ on a long string.
• Avoid .* in the middle of patterns: foo.*bar forces the engine to scan to the end of the string and backtrack. If you know the separator, be specific: foo[^b]*bar.
• Use character classes instead of alternation: [aeiou] is faster than a|e|i|o|u. Alternation causes the engine to try each branch sequentially.
• JavaScript has no possessive quantifiers: in PCRE you'd use a++ to prevent backtracking into the quantifier. In JS, simulate with a lookahead workaround: (?=(a+))\1 captures greedily without allowing the engine to give back characters.
• Pre-compile regexes outside loops: in Node.js, /pattern/flags literals are compiled once. Avoid new RegExp(str) inside a loop unless the pattern changes, each constructor call re-compiles the regex.

Related articles

• 4 min readJavaScript Regex Flags: g, i, m, s, u, and v ExplainedJavaScript regex flags change how patterns match. Learn when to use global /g, case-insensitive /i, multiline /m, dotAll /s, unicode /u and the new /v flag, plus how the...
• 4 min readRegex Replace in JavaScript: String.replace() and replaceAll() with PatternsMaster JavaScript regex replace: String.replace() with capture groups, replaceAll() vs global flag, using functions as replace values, and common patterns for sanitizing...
• 4 min readRegex Email Validation: Patterns, Edge Cases, and Best PracticesEmail validation regex needs to balance strictness with real-world email formats. Learn why the perfect email regex is impossible, pragmatic patterns that work, RFC 5322...
• 5 min readRegex Lookahead and Lookbehind: Zero-Width Assertions ExplainedRegex lookaheads and lookbehinds match positions without consuming characters. Here's how positive and negative lookahead/lookbehind work, with practical examples for password...
• 4 min readRegex Named Capture Groups: ?<name> Syntax and Use CasesNamed capture groups in regex use (?<name>...) syntax to give match groups readable names instead of positional indexes. Learn named groups in JavaScript, Python, and practical...
• 7 min readRegex Patterns: Ready-to-Use Patterns for Email, Phone, URL, and MoreReady-to-use regular expression patterns for validating emails, phone numbers, URLs, dates, credit cards, IP addresses, and more. Copy and adapt these patterns for your...
• 4 min readRegex Quantifiers: *, +?, {n}, and Greedy vs Lazy MatchingRegex quantifiers control how many times a pattern matches: * (zero or more), + (one or more), ? (zero or one), {n,m} (specific range). Here's how each quantifier works and...
• 9 min readCatastrophic Backtracking: The Regex That Kills Your ServerOne regex with nested quantifiers can reduce your server to 100% CPU in milliseconds. This is how catastrophic backtracking works, how to spot it, and how to fix it.
• 12 min readThe 2026 Regex Cheatsheet (PCRE, JS, Python: Side by Side)A dense reference for modern regex: anchors, character classes, quantifiers, lookarounds, capture groups, named groups, Unicode, and the dialect differences that actually bite.

Pillar