Regex Tester

Written byOleh Soloninupdated 25 September 2026

Regular expression

Flags

g, i, m, s, u — as in JavaScript.

Text

Replacement

Result

Matches2
Match list8: 2026-08-01 29: 2026-09-15
Capture groups8: 2026 | 08 | 01 29: 2026 | 09 | 15
After replacementRelease 01.08.2026, next one 15.09.2026
Flags appliedg

Matches, groups and replacement at once

Shows every match and its position, the capture groups, and the result of a replacement.

A regular expression is almost never right first time. Debugging is a loop of tweak-and-look, and it goes faster when matches and capture groups are visible side by side.

The replacement field removes the second half of the work. References like $1 and $2 substitute the groups, so reordering an ISO date into a human one takes one line and the result appears immediately.

How to use

Enter the pattern without the slashes that surround it in JavaScript.
Set the flags: i ignores case, m makes anchors work per line, u enables Unicode handling.
Add a replacement if you want one; $1, $2 stand for the contents of the capture groups.

Traps the tester exposes

Quantifiers are greedy: .* takes everything it can and gives back only what the rest of the pattern strictly needs. A question mark after it makes it lazy — .*? takes the minimum. On a line with two tags that is the difference between one match and two.

Accented text has its own trap: \w in JavaScript knows only unaccented Latin letters, digits and the underscore. \w+ on "café naïve" splits the words at every accent. \p{L} matches letters of any alphabet, with the u or v flag; without either it is not a class at all.

Every row comes from the tester on this page. The third is why accented words so often "go missing" when a pattern is copied from an example written for plain English.
Pattern and flags	Text	Matches	What is found
<b>.*</b>, g	<b>a</b> and <b>b</b>	1	the whole line
<b>.*?</b>, g	<b>a</b> and <b>b</b>	2	<b>a</b> and <b>b</b> separately
\w+, g	café naïve	3	caf, na, ve
\p{L}+, gu	café naïve	2	café and naïve

The g flag and replacement

To list every match, the tester always searches with the g flag. The replacement, though, runs with exactly the flags you typed: without g your code will replace only the first match, and the preview now shows the same.

Until recently g was added to the replacement too, and the preview promised a replace-all even for code that would change one occurrence. The default example shows it at once: with the i flag only the first date changes.

Both rows come from the tester on this page using the default example. The match list is the same; the replacement is not — in the second row it fired once, exactly as it would in code without the g flag.
Flags	Matches listed	Result of replacing with $3.$2.$1
g	2	Release 01.08.2026, next one 15.09.2026
i	2	Release 01.08.2026, next one 2026-09-15

What this calculator shows

Every match with its position in the text
The capture groups for each match
The text after replacement, with group substitution

What to keep in mind

The syntax is JavaScript's — the same flags and quirks as in a browser or Node.
The g flag is added automatically, otherwise iterating matches would loop on the first one.

FAQs

What do the g, i and m flags do?

g finds every match rather than the first; i ignores case; m makes ^ and $ apply per line rather than to the whole text. Letting the dot cross line breaks is the s flag, which people confuse with m.

Why does \w miss accented letters?

Because in JavaScript \w means unaccented Latin letters, digits and the underscore, and the flags barely change that: only i together with u or v adds the Kelvin sign K (U+212A) and the long s ſ (U+017F), which fold to k and s. For letters of any alphabet, write \p{L} with the u or v flag — without them \p{L} is not recognised as a class at all.

How do I reference capture groups?

As $1, $2 and so on in bracket order. Named groups written (?<name>...) are referenced as $<name>, and the whole match as $&.

Why does my pattern match too much?

Most likely greedy quantifiers: .* takes as much as it can. Add a question mark — .*? — to make them lazy.

Why does the preview's replacement differ from my code's?

It used to: the tester added the g flag to the replacement as well. Now the replacement runs with your flags as written, so without g only the first match is replaced — just as in your code. The match list is still complete.

Do regular expressions behave the same everywhere?

No. PCRE, Python and JavaScript differ on lookbehind, named groups and Unicode properties. This uses the JavaScript flavour.

Worked example

Reordering a date

Input: (\d{4})-(\d{2})-(\d{2}) replaced with $3.$2.$1

Output: 2026-08-01 becomes 01.08.2026

Note: Three capture groups — year, month, day — reversed in the replacement. It is the most common practical use of regular expressions there is.

Useful links

All tools in Dev Tools

Regex Tester

Result

Related tools

Query String Parser

Text Cleaner

JSON formatter and validator

Useful links