Regex Tester & Debugger

What is a regular expression, and how does matching work?

A regular expression is a small pattern language for describing text. The engine reads your pattern left to right, and at each position in the subject string it tries to satisfy the next piece of the pattern.

Two behaviours explain almost everything a regex does:

• It scans forward. Matching is attempted at position 0. If that fails, position 1, then 2, and so on. This is why cat finds "cat" anywhere in "the cat sat".
• Quantifiers are greedy, then backtrack. .* first consumes everything to the end of the line, then gives characters back one at a time until the rest of the pattern can match.

That second point is the source of most surprising results. Against <a><b>:

<.*>    matches  <a><b>    ← greedy: took everything, backtracked to the last >
<.*?>   matches  <a>        ← lazy: took as little as possible
<[^>]*> matches  <a>        ← explicit: can never cross a > at all

The third form is usually the best of the three. It states the intent directly instead of relying on backtracking, and it is faster.

Flags change the rules, not the pattern

The m flag is the one worth understanding properly. Without it, ^ means "start of the whole string". With it, ^ means "start of any line". Against a three-line log file, ^ERROR without m can match at most once; with m it can match on every line.

The u flag matters more than it looks. . without it matches one UTF-16 code unit, so /^.$/ fails against a single emoji — the emoji is two units. With u, it succeeds.

Capture groups: numbered and named

Parentheses do two jobs at once: they group for quantifiers, and they capture the matched text for later use.

Pattern:  (\d{4})-(\d{2})-(\d{2})
Subject:  2026-03-14

Full match  →  2026-03-14
$1          →  2026
$2          →  03
$3          →  14

Named groups make longer patterns readable and survive reordering:

Pattern:  (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})

$<year>   →  2026
$<month>  →  03
$<day>    →  14

Three group variants are worth keeping straight, because they look similar and behave very differently:

"Consumes text" is the key column. Lookarounds check a condition at the current position without moving forward, which is why (?=.*\d)(?=.*[a-z]).{8,} can test several password rules against the same characters.

A group that did not participate in the match reports undefined, not an empty string. With (a)?(b) against "b", $1 is undefined. The match table on this page shows that distinction explicitly, because in code the two behave differently.

Escaping: which characters are special

Twelve characters have meaning outside a character class and need a backslash to be matched literally:

.  ^  $  *  +  ?  (  )  [  ]  {  }  |  \

So to match a literal price you need:

Wrong:  $19.99      → $ is an anchor, . is any character
Right:  \$19\.99    → matches only "$19.99"

Inside a character class the rules are different and smaller. Only ^ (when first), ], \ and - (when between two characters) are special:

[.+*]     matches a literal dot, plus or asterisk — no escaping needed
[a-z-]    a trailing hyphen is literal
[\]\\]     a literal ] and a literal backslash

When a pattern comes from user input, escape it rather than trusting it. The String Escaper has a regex target that escapes every metacharacter for you.

Remember there are two layers when a pattern lives inside a string literal. To match one backslash the regex is \\, and writing that regex in a JavaScript string needs "\\\\". This page takes the raw pattern, so you type \\ — the same as inside /.../ literal notation.

Examples: how to solve common matching tasks

Common regex mistakes

• Forgetting g and wondering where the other matches went. Without the global flag only the first match is returned. The tool states which mode you are in below the results.
• Using ^ and $ without m on multi-line text. They anchor to the whole string, so a pattern that works on one line fails on a file.
• Unescaped dots. example.com also matches "exampleXcom". Write example\.com.
• Greedy .* swallowing too much. Prefer a negated class such as [^>]* over .*? where possible; it is clearer and faster.
• Nested quantifiers causing catastrophic backtracking. (a+)+$ against a long run of "a" followed by "b" can take exponential time. If a pattern has a quantifier inside a quantified group, restructure it.
• Zero-length matches in a loop. A pattern like a* matches emptily at every position. In a manual exec loop you must advance lastIndex yourself or it never ends. Zero-length matches are marked in the highlight panel here.
• Reusing a global regex object. A /g regex keeps lastIndex between calls, so test() on the same regex alternates true and false. Create it fresh, or reset lastIndex.
• Trying to parse HTML. Nested, optional and self-closing tags are not a regular language. Use DOMParser for structure and regex only for narrow, well-defined fragments.
• Copying a PCRE pattern from a PHP or Python answer. \A, (?>...) and possessive quantifiers throw a syntax error in JavaScript. The tool names the specific construct when it spots one.

Use cases

• Validating a form field. Build the pattern here against real and deliberately malformed samples before shipping it.
• Extracting fields from log lines. Named groups turn an unstructured line into labelled values you can read straight off the match table.
• Bulk find and replace in an editor. VS Code, IntelliJ and Sublime all use JavaScript-compatible syntax with $1 substitution, so a pattern verified here transfers directly.
• Writing a URL rewrite rule. Test the capture groups before putting them into an Nginx or CDN configuration.
• Auditing an inherited pattern. Paste a regex from a codebase and see exactly what it matches, and what it misses.
• Cleaning up scraped text. Iterate on a replacement against a sample until the output is right.

Privacy and limits

The pattern and test string stay in your browser; matching runs on the page's own JavaScript engine and nothing is uploaded.

Practical limits keep the page responsive: test strings are capped at 200,000 characters, highlighting at 500 matches, and the detail table lists the first 50. That is comfortably enough to verify a pattern, and it means a pathological expression cannot lock the tab.