Regex tester

Reembun. (2026, July 28). Regex tester. https://reembun.com/regex-tester

Flags

Flag	Effect
g	Find all matches rather than stopping at the first
i	Case insensitive
m	^ and $ match at line boundaries, not just string boundaries
s	. also matches newlines
u	Unicode mode; enables \p{...} property escapes

The g flag has a side effect worth knowing: it makes a regex object stateful. Reusing the same global regex across calls without resetting lastIndex produces intermittent misses, and it is one of the most common bugs in JavaScript code that uses regular expressions.

Greedy versus lazy

This is the single most frequent cause of a pattern matching more than intended.

Input:   <a>one</a> <a>two</a>

<a>.*</a>    matches the whole string (greedy)
<a>.*?</a>   matches <a>one</a> (lazy)

Greedy quantifiers take as much as they can and backtrack only when forced. Adding ? after *, +, ? or {n,m} makes them take as little as possible.

Capture groups

(\d{4})-(\d{2})-(\d{2})

Three numbered groups, available as $1, $2, $3 in a replacement.

Named groups are usually clearer:

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

Referenced as $<year> in a replacement, and far easier to maintain than positional numbers when the pattern changes.

Use (?:...) for a group you need for grouping but do not want to capture. It is marginally faster and keeps your numbering clean.

Common patterns

Purpose	Pattern
Digits only	^\d+$
Word boundary	\bword\b
Trim whitespace	`^\s+
Duplicate words	\b(\w+)\s+\1\b
HTML tag	<[^>]+>
Repeated blank lines	\n{3,}

Where regex is the wrong tool

Parsing HTML. HTML is not a regular language. A pattern that works on your test input will fail on nested tags, attributes containing angle brackets, or comments. Use a parser: DOMParser in the browser is built in.

Validating email addresses. The RFC-compliant pattern is thousands of characters and still accepts addresses no mail server will deliver to. Check for an @ with something either side, then send a confirmation email. That is the only real validation.

Parsing JSON, CSV or code. All need a parser that understands nesting and quoting.

Catastrophic backtracking

Nested quantifiers over overlapping character classes can make matching time grow exponentially with input length:

(a+)+$        against  aaaaaaaaaaaaaaaaaaaaaaaaaaX

This hangs. If a regex runs on untrusted input, such as a search box, a log parser or a validation rule, a pattern like this is a denial-of-service vulnerability, and it has taken down production systems at several large companies. Avoid nesting quantifiers, and prefer explicit character classes over . wherever you can.