Regex Tester

Q: Why doesn’t \w match accented letters?

In JavaScript, \w only stands for A–Z, a–z, 0–9 and _. For letters in any language, use \p{L} with the u flag, e.g. [\p{L}\d_]+ for a word such as “café”.

Q: What is the difference between greedy and lazy?

Greedy quantifiers (*, +, {2,}) take as much text as possible, lazy ones with a trailing question mark (*?, +?) as little as possible. On “x”, <.+> matches the whole string, <.+?> only “”.

Q: How do I name a capture group?

Use (?<name>…). In code you read it via match.groups.name, in a replacement string with $<name>, and inside the pattern with the backreference \k<name>.

Enter a pattern, pick flags, paste your test string: the regex tester shows every match with its index, the contents of numbered and named capture groups and explains each part of the pattern in plain English. Matching uses your browser’s JavaScript engine (ECMAScript).

Regular expression (pattern)

Enter it without the surrounding slashes, e.g. \d+ rather than /\d+/. The pattern is part of the link and can be shared – the test string is not.

g – global: find all matches

i – ignore case

m – multiline: ^ and $ match at each line

s – dotAll: the dot also matches line breaks

u – Unicode: code points, \p{…}, stricter syntax

y – sticky: only contiguous matches from index 0

d – report group positions (indices)

v – unicodeSets: set operations in […] (instead of u)

Your inputs are saved in this browser only.

Test stringThe text to search. It stays in your browser and is not included in the link.

Your text stays in your browser – it is not sent, not stored and not added to the address bar.

Result

Result: 2 matches
Matches: No. Index Length Match
1 21 10 2026-09-27
2 45 10 2026-10-15
Groups per match: No. Group Name Value
1 1 jahr 2026
1 2 monat 09
1 3 tag 27
2 1 jahr 2026
2 2 monat 10
2 3 tag 15
Pattern explained: Token Meaning
(?<jahr> start of group 1, named “jahr”
› \d a digit 0–9
› {4} the preceding item exactly 4 times
) end of group
- the literal text “-”
(?<monat> start of group 2, named “monat”
› \d a digit 0–9
› {2} the preceding item exactly 2 times
) end of group
- the literal text “-”
(?<tag> start of group 3, named “tag”
› \d a digit 0–9
› {2} the preceding item exactly 2 times
) end of group
As a JavaScript literal: /(?<jahr>\d{4})-(?<monat>\d{2})-(?<tag>\d{2})/g

No.	Index	Length	Match
1	21	10	2026-09-27
2	45	10	2026-10-15

No.	Group	Name	Value
1	1	jahr	2026
1	2	monat	09
1	3	tag	27
2	1	jahr	2026
2	2	monat	10
2	3	tag	15

Token	Meaning
(?<jahr>	start of group 1, named “jahr”
› \d	a digit 0–9
› {4}	the preceding item exactly 4 times
)	end of group
-	the literal text “-”
(?<monat>	start of group 2, named “monat”
› \d	a digit 0–9
› {2}	the preceding item exactly 2 times
)	end of group
-	the literal text “-”
(?<tag>	start of group 3, named “tag”
› \d	a digit 0–9
› {2}	the preceding item exactly 2 times
)	end of group

How it is calculated

This regex tester uses the JavaScript flavor of regular expressions as defined by the ECMA-262 standard and implemented by your browser. A pattern that works here works exactly the same in String.prototype.match, matchAll, replace and RegExp.prototype.test – in Chrome, Firefox, Safari and Node.js.

Reading the result

Matches: every match with its index (zero-based character position, counted in UTF-16 code units as JavaScript does – an emoji counts as 2) and length. Line breaks are shown as ↵, tabs as ⇥.
Groups per match: what each pair of parentheses captured – numbered groups ( ) and named groups (?<name> ). “Did not participate” means the group sits in an alternative that wasn’t taken. With the d flag you also get the position of each group.
Pattern explained: every token in plain English; indented rows (›) are inside a group.

The flags

g finds all matches instead of just the first, i ignores case, m makes ^ and $ work per line, s lets the dot match line breaks. u treats emoji and other characters outside the Basic Multilingual Plane as one character and enables Unicode properties such as \p{L} (any letter, including é or ñ). v is the newer version of u with set operations like [\p{L}--[a-z]]; u and v can’t be combined. y (“sticky”) only finds matches that follow each other without gaps.

Protection against infinite loops and hangs

Patterns such as a* or \b can produce empty matches. Like JavaScript itself, the tester then advances by one character (a full code point with u/v), so there is no infinite loop. At most 1,000 matches are searched for.

The bigger danger is catastrophic backtracking (ReDoS): nested quantifiers like (a+)+$ try an exponential number of combinations on a string that doesn’t match – 30 characters can keep the engine busy for minutes. That’s why the search runs in a separate background thread and is stopped after 2 seconds; the page stays responsive. Avoid such patterns in your own code too, especially on user input.

Differences from other regex flavors

PCRE (PHP), Python, Java and .NET differ in the details: JavaScript has no possessive quantifiers (a++), no atomic groups and no \A or \Z anchors; \w only covers A–Z, a–z, 0–9 and the underscore – for accented letters use \p{L} with the u flag.

Your test string is not sent, not stored and not written into the link – only the pattern and the flags are.

Frequently asked questions

How do I test a regular expression?

Type the pattern without slashes into the top field, tick the flags you need and paste your text. All matches are highlighted in the text straight away and listed with their index; below that you see what each group captured.

Why doesn’t \w match accented letters?

In JavaScript, \w only stands for A–Z, a–z, 0–9 and _. For letters in any language, use \p{L} with the u flag, e.g. [\p{L}\d_]+ for a word such as “café”.

What is the difference between greedy and lazy?

Greedy quantifiers (*, +, {2,}) take as much text as possible, lazy ones with a trailing question mark (*?, +?) as little as possible. On “x”, <.+> matches the whole string, <.+?> only “”.

How do I name a capture group?

Use (?<name>…). In code you read it via match.groups.name, in a replacement string with $<name>, and inside the pattern with the backreference \k<name>.

Why was my search stopped?

It took longer than 2 seconds – usually because of catastrophic backtracking with nested quantifiers such as (\w+)*. Simplify the pattern: don’t nest quantifiers, make alternatives unambiguous and anchor it with ^ and $.

Does the result also apply to PHP or Python?

For simple patterns it usually does, but it is only guaranteed for JavaScript. PHP (PCRE) and Python support extra syntax such as possessive quantifiers or \A, and Python traditionally writes named groups as (?P<name>…).

Sources and legal basis

As of: 27 September 2026