Regex Tester - Live Matches, Named Groups, Replace

A regular expression is a compact description of a set of strings: a pattern that a text either matches or does not. The catch is that there is no single regex language. JavaScript, Python, PCRE, Java, and the POSIX tools each support slightly different syntax and features, so a pattern that is perfect in one can be invalid or subtly wrong in another. This tester compiles your pattern with the browser’s own ECMAScript engine, which means what you see here is exactly what a browser or Node.js will do, and it is the right place to test regex destined for JavaScript.

As you type, the pattern is applied to the test string and every match is highlighted in place. The highlight layer sits behind the text and scrolls with it, so on a long input the colours stay lined up with the characters they mark rather than drifting as you scroll, a small detail that makes a real difference when you are scanning a wall of log lines. Below the text, each match is broken out with its position and its capture groups so you can see not just that the pattern matched, but what each part of it captured.

The six flags each change one thing. g (global) keeps finding matches after the first instead of stopping. i (ignore case) makes letters match regardless of case. m (multiline) makes ^ and $ match at every line break rather than only the very start and end of the text. s (dotall) lets . match newline characters, which it normally does not.

The last two are less familiar but useful. u (unicode) makes the engine treat the pattern as Unicode code points, which is what you want when working with emoji or non-Latin scripts, and it enables Unicode property escapes. y (sticky) anchors each match to the exact position where the last one ended, which is how tokenizers walk through input one piece at a time without skipping ahead. Toggling any flag re-runs the match immediately so you can see its effect.

One caution worth carrying from here into production code: JavaScript’s engine can be made to work extremely hard by patterns with nested, overlapping quantifiers. Against the right input, something like (a+)+$ triggers catastrophic backtracking and the match appears to hang. It is harmless while you experiment here, but when the same pattern runs on a server against text a user controls, it becomes a denial-of-service risk, so prefer specific, non-overlapping pieces and anchor where you can.

Once a pattern extracts the data you want, the JSON Formatter will format and validate a JSON result, and the Diff Checker helps compare the text before and after a replace to confirm exactly what changed.