Regular expressions are a compact language for describing patterns in text, perfect for validation, search-and-replace, and parsing. They are also famously easy to get subtly wrong. The ToolOrbit Regex Tester lets you write a JavaScript pattern, see matches highlighted live against your sample text, and inspect each capture group as you type.
How a regex is built
A pattern is a mix of literal characters and metacharacters. Character classes match types of characters, quantifiers control repetition, and anchors tie a match to the start or end of a line. Parentheses create capture groups that pull out the parts you care about.
Pattern: (\d{4})-(\d{2})-(\d{2})
Text: Release date: 2026-06-29
Group 1: 2026 Group 2: 06 Group 3: 29Flags that change behavior
- g (global): find all matches, not just the first
- i (ignore case): match regardless of upper or lower case
- m (multiline): make the anchors match at line breaks, not just string ends
- s (dotall): let the dot match newline characters too
- u (unicode): handle full Unicode code points correctly
The tester shows every match and its groups, so you can immediately see why a pattern caught too much or missed an edge case.
Using the Regex Tester
Enter your pattern and toggle the flags you need, then paste sample text to validate against. Live highlighting shows matches in place and the group panel breaks out each capture. Because everything runs in your browser, you can safely test against real log lines or data samples without uploading them anywhere.
Tips for cleaner patterns
Anchor your patterns when you mean to match a whole value, escape characters that have special meaning such as the dot and parentheses, and reach for named groups to make complex expressions readable. Remember that JavaScript regex differs from other engines in places, so test in the engine you will actually deploy to, which is exactly what this tester uses.
The character classes you will live in
| Class | Matches | Watch out for |
|---|---|---|
| \d | Digits | Matches Unicode digits too, not just 0–9 |
| \w | Word chars [A-Za-z0-9_] | Underscore is included |
| \s | Whitespace | Includes tabs and newlines |
| \b | Word boundary | Not a character — zero-width |
Backtracking is where regex silently turns catastrophic: patterns with nested quantifiers like (a+)+ on pathological inputs can take hours (the classic ReDoS). If a pattern works on samples but a large input freezes the tester, that is the smell. Prefix-chedule your alternations, keep quantification flat, and test the worst case you can find before shipping the expression to production.
