Regex Tester

Character classes

\d   digit (0-9)         \D   non-digit
\w   word char (a-z 0-9 _)  \W   non-word char
\s   whitespace          \S   non-whitespace
.    any char (except \n) [abc]  one of a, b, or c
[^a] anything except a   [a-z]  range a to z

Quantifiers

*       0 or more (greedy)    *?       0 or more (lazy)
+       1 or more (greedy)    +?       1 or more (lazy)
?       0 or 1                ??       0 or 1 (lazy)
{n}     exactly n             {n,}     n or more
{n,m}   n to m                {n,m}?   n to m (lazy)

Anchors and boundaries

^      start of string (or line with /m)
$      end of string (or line with /m)
\b     word boundary
\B     non-word boundary
\A     start of input (no /m effect)
\z     end of input

Groups and references

(abc)         capturing group
(?:abc)       non-capturing group
(?<name>abc)  named group (`match.groups.name`)
\1            backreference to group 1
\k<name>      backreference to named group

Lookarounds (zero-width)

(?=abc)   positive lookahead — followed by abc
(?!abc)   negative lookahead — NOT followed by abc
(?<=abc)  positive lookbehind — preceded by abc
(?<!abc)  negative lookbehind — NOT preceded by abc

Example: \d+(?=px) matches digits before "px" without consuming "px".

Unicode (with /u flag)

\p{L}      any letter (any script)
\p{N}      any digit
\p{Hangul} Korean syllables
\p{Han}    Chinese characters
\p{Emoji}  emoji characters

1. Catastrophic backtracking (ReDoS)

Patterns like (a+)+b on inputs like aaaaaaaa! can take exponential time. The famous Cloudflare 2019 outage was caused by a regex with this property. Avoid nested quantifiers ((x+)+, (x*)*, (x|x)*); use atomic groups or possessive quantifiers if your engine supports them. RE2 prevents this by construction.

2. Greedy vs lazy mismatch

<.+> matches as much as possible — <b>hello</b> becomes one big match including the inner text. Use lazy <.+?> for the smallest match. Better: exclude > with <[^>]+>.

3. Forgetting to escape special characters

. matches any character, not literal dot. To match a real period, escape it: \.. Same for + * ? ( ) [ ] | \. When building a regex from user input, always pass through str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").

4. Anchor confusion in /m mode

Without /m, ^ and $ are start/end of string. With /m, they match start/end of each line. To always anchor on the whole string regardless of mode, use \A and \z (not supported in JavaScript).

5. Regex for HTML / JSON / email

Don't. HTML and JSON aren't regular languages — nesting and quoting break naive patterns. Email addresses fully comply with RFC 5322 only via a ~5,000-char regex. Use real parsers (DOMParser, JSON.parse) and let your library handle the exact format. Regex is for "good enough" pattern matches.

Is my data stored or sent anywhere?

No. All regex processing happens in a sandboxed Web Worker in your browser. No data leaves your device.

Which regex flavor does this use?

JavaScript's built-in RegExp engine — ECMAScript regex spec. Supports lookahead, lookbehind, named groups, Unicode property escapes, and 6 flags (gimsuy). Some advanced PCRE features (atomic groups, possessive quantifiers, recursion) are not available.

What do the flags mean?

g (global) finds all matches, i ignores case, m makes ^ and $ match line boundaries, s makes . match newlines, u enables full Unicode mode (required for \p{} property escapes), y makes the regex sticky.

Why does my regex run forever then time out?

Catastrophic backtracking. Your pattern has nested quantifiers that explore exponentially many combinations on certain inputs. Common culprits: (a+)+, (.*)*, (a|a)+. Rewrite without overlapping alternatives or use a non-backtracking engine (RE2).

How do I match Unicode like Korean or emoji?

Add the u flag and use \p{Hangul} for Korean, \p{Han} for Chinese, \p{Emoji} for emoji. Without the u flag, . doesn't match emoji surrogate pairs correctly.

What's the difference between greedy and lazy quantifiers?

Greedy (.+) matches as much as possible, then backtracks if needed. Lazy (.+?) matches as little as possible, then expands. Greedy is the default; add ? after a quantifier to make it lazy.