English
Test regular expressions with animated match highlighting.
Last updated
A regex tester lets you type a regular expression and immediately see what it matches in sample text. Developers use regex (regular expressions) to validate input, extract data from strings, search logs, clean text, build editor commands, and write search-and-replace rules.
Regex feels cryptic at first because a few symbols carry a lot of meaning. A live tester demystifies it: every character you type updates the highlighted matches and capture groups, so you can experiment until the pattern does exactly what you want.
Different programming languages use slightly different regex engines (JavaScript, PCRE, Python, Java, Go, .NET). The fundamentals — characters, character classes, quantifiers, anchors, and groups — work everywhere. The advanced features (lookbehind, named groups, possessive quantifiers) are where engines diverge.
\d+ matches a run of digits, but it doesn't know whether the number makes sense.g finds every match, i ignores case, m makes ^ and $ match line ends, s lets . match newlines.(...) extract parts of a match, not just check whether the whole string matches — essential for parsing.Enter a regular expression in the pattern field. Don't include the surrounding / slashes — they're a JavaScript literal syntax, not part of the pattern itself.
Most often you'll want g (find all matches) and i (case-insensitive). Use m for line-by-line anchors and s to let . match newlines.
Drop sample text into the test area. Matches highlight as you type, and capture groups are listed underneath the match list.
Each match shows its position, full text, and any captured groups. Use this to verify the pattern catches what you want and skips what you don't.
Tighten quantifiers, add anchors (^, $), or escape literal characters (\., \?) until the matches and groups are exactly what your code needs.
The 80% of regex you'll use 99% of the time. Bookmark this — it's the fastest way to remember the syntax. For the full grammar, see MDN's regular expressions guide.
| Token | Meaning | Example |
|---|---|---|
. | Any single character (except newline) | a.c matches abc, a-c |
\d \D | Digit / non-digit | \d+ matches 123 |
\w \W | Word char (letter/digit/_) / non-word | \w+ matches hello_1 |
\s \S | Whitespace / non-whitespace | \s+ matches spaces and tabs |
[abc] | Any of a, b, or c | [aeiou] matches a vowel |
[^abc] | None of a, b, or c | [^0-9] matches non-digits |
* + ? | 0+, 1+, 0 or 1 of the previous | a+ matches a, aaa |
{n} {n,m} | Exactly n / between n and m | \d{3,5} 3 to 5 digits |
^ $ | Start / end of string (or line with m) | ^Error line begins with Error |
(...) | Capture group | (\d+) captures the digits |
(?:...) | Non-capturing group | (?:foo|bar) group without capture |
a|b | Alternation — a or b | yes|no |
\b | Word boundary | \bcat\b matches cat not cats |
^[\w.+-]+@[\w-]+\.[\w.-]+$learner@coddy.tech
This catches the basic shape something@something.something. Real-world email validation is much more permissive than this — for forms, prefer type="email" and a server-side check.
\d+Lesson 12 has 3 tasks and 2 quizzes.
With the g flag, this finds every digit run: 12, 3, 2. \d+ is the regex equivalent of "one or more digits".
/users/(\d+)/users/42/profile
The full match is /users/42, and the capture group (\d+) extracts just 42. Capture groups are how you actually *use* a regex match in code.
<.+><.+?><b>hello</b>
The greedy version matches the entire string <b>hello</b> because .+ grabs as much as it can. The lazy version (+?) stops at the first >, so it matches only <b> and </b>.
., ?, +, (, ), [, ], {, }, \, ^, $, |. When you mean them literally, prefix with \..* greedily and matching far more than intended — switch to .*? or a more specific character class.\d, \w, [abc]) and quantifiers (*, +, ?, {n,m}). Use a regex tester to iterate until the pattern matches exactly the cases you want.\w mean in regex?\w matches a word character — a letter, a digit, or an underscore. \W is the opposite (any non-word character). The exact set depends on the engine and the Unicode flag..* matches as much as possible. Switch to a lazy quantifier (.*?) or use a more specific character class to stop where you want.re, Java, Go, and .NET each support slightly different flags and advanced features (lookbehind support, named groups, possessive quantifiers).