How to Test JavaScript Regex Online: Flags, Groups, Patterns

How to Test a Pattern in Your Browser

Type the pattern without the surrounding slashes, paste some sample text, and switch on the flags you need: g to find every match, i to ignore case, m so ^ and $ work per line, and s so a dot also matches line breaks. Matches are highlighted as you type, and the match details show where each match starts and what each group captured.

The tester runs JavaScript regex only. The Regex Tester page lists which features from other languages are not available, such as Python's (?P<name>...) groups and PCRE's atomic groups.

Using Your Pattern in JavaScript Code

Once a pattern works in the tester, it behaves the same way in JavaScript with the same flags. These are the methods you will use most often:

// test(): does the text match at all?
/^\d{5}$/.test("12345");   // true
/^\d{5}$/.test("1234");    // false

// match() with the g flag: every match as an array
"a1 b22 c333".match(/\d+/g);   // ["1", "22", "333"]

// matchAll(): every match with its groups
const text = "Released 2026-04-22, updated 2026-05-16";
for (const m of text.matchAll(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g)) {
  console.log(m.groups.year);   // "2026", then "2026"
}

// replace(): reuse groups in the replacement
"2026-04-22".replace(/(\d{4})-(\d{2})-(\d{2})/, "$3/$2/$1");               // "22/04/2026"
"2026-04-22".replace(/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/, "$<d>/$<m>/$<y>"); // "22/04/2026"

In a replacement string, $1 inserts group 1 and $<name> inserts a named group.

Common Regex Mistakes

• Forgetting the g flag. Without it, \d+ on a1 b22 c333 finds only 1. With it, you get 1, 22 and 333.
• Greedy matches that run too far. .* and .+ take as much text as they can. Use the lazy .*? or a negated class such as [^<]* instead.
• Unescaped special characters. example.com also matches exampleXcom, because a dot means any character. Write example\.com.
• Missing anchors in validation. \d{5} finds 12345 inside 123456. To check that the whole value is five digits, use ^\d{5}$.
• Single backslashes in a string pattern. In a JavaScript string, "\d" is just the letter d, so the backslash never reaches the regex:

new RegExp("\d+").test("123");    // false: "\d" in a string is just "d"
new RegExp("\\d+").test("123");   // true
/\d+/.test("123");                 // true: no extra escaping in a regex literal

• Reusing a global regex with test(). A regex with the g flag remembers where its last match ended, so repeated calls on the same text alternate between true and false:

const re = /a/g;
re.test("a");   // true
re.test("a");   // false: the search continued from the end of the last match
re.test("a");   // true

Drop the g flag when you only need a yes or no answer. Also note that replaceAll() throws a TypeError if you pass it a regex without the g flag. Finally, patterns with nested quantifiers such as (a+)+ can take exponentially longer as the text grows; the Regex Tester page explains this catastrophic backtracking and how the tester stops slow patterns.

Moving a Pattern to Python or Java

Most of the syntax above works in Python and Java too, but some details differ, so test the final pattern in the language where it will run:

• Named groups in Python: Python writes them as (?P<year>...). JavaScript reports that as an invalid group, and Python 3.12 rejects JavaScript's (?<year>...) form.
• Flags: JavaScript's i, m and s flags correspond to re.IGNORECASE, re.MULTILINE and re.DOTALL in Python, and to CASE_INSENSITIVE, MULTILINE and DOTALL in Java's Pattern class. There is no g flag: Python uses re.findall() or re.finditer() to get every match.
• Backslashes in Java: patterns are usually written as string literals, so every backslash is doubled. The regex \d+ becomes "\\d+" in Java code. Java writes named groups the same way as JavaScript.

Conclusion

Write the smallest pattern that works, test it against real examples including the edge cases you expect, then anchor it if you are validating whole values. Turn on only the flags you need, and test the pattern again in the language where it will run.