Regex Tester

Test and debug regular expressions in real-time with match highlighting, capture groups, replacement preview, and pattern explanation. Supports all JavaScript regex features.

What is Regex Tester?

A Regex Tester provides an interactive environment to write, test, and debug regular expressions in real-time. Regular expressions (regex or regexp) are sequences of characters that form search patterns, capable of matching, extracting, validating, and transforming text with extraordinary precision and conciseness. They are one of the most powerful and universally applicable tools in programming—supported natively in JavaScript, Python, Java, Ruby, Go, PHP, Perl, Rust, and virtually every programming language, as well as text editors, command-line tools, and databases. Common regex use cases include form validation (checking that an email, phone number, or URL matches the expected format), data extraction (pulling specific fields from log files, HTML, or API responses), text search and replace operations that are far more precise than simple string matching, URL routing in web frameworks, tokenization in compilers and parsers, and sanitizing user input. The challenge with regex is that patterns can be difficult to write correctly, hard to read, and subtle bugs in a regex can cause silent data extraction failures or security vulnerabilities like ReDoS (Regular Expression Denial of Service) from catastrophic backtracking. An interactive tester that highlights matches in real-time and explains what each pattern component does dramatically accelerates regex learning and debugging.

How to Use Regex Tester

Enter your regular expression pattern in the Pattern field at the top—do not include the surrounding slashes, just the pattern itself (e.g., \d{3}-\d{4} to match phone segments). Type or paste your test string in the large text area below. All matches are highlighted in real-time with color-coded spans as you type. Enable flags using the toggles: g (global—find all matches, not just the first), i (case-insensitive), m (multiline—^ and $ match line boundaries), s (dotAll—dot matches newlines too), u (Unicode mode), and y (sticky—match only at the current position). The match results panel shows every match with its index position and any captured group values in parentheses. To preview a find-and-replace operation, enter a replacement string in the Replace field—you can use $1, $2 to reference capture groups. Browse Common Patterns for pre-built regexes for emails, URLs, IP addresses, dates, and other frequently needed formats. The pattern explanation panel breaks down your regex into components and describes what each part matches.

FAQ

What regex flavor does this tester use?

This tool uses JavaScript (ECMAScript) regular expressions, which are the standard for web browsers and Node.js. JavaScript regex supports most standard features: character classes (\d, \w, \s), quantifiers (+, *, ?, {n,m}), anchors (^, $), groups (capturing and non-capturing), alternation (|), lookahead (?=, ?!), lookbehind (?<=, ?<!), and Unicode property escapes (\p{}) in Unicode mode. It does not support some features from PCRE (PHP, Perl) like possessive quantifiers or atomic groups.

What do the regex flags do?

g (global): find all matches in the text, not just the first. i (case-insensitive): treat uppercase and lowercase letters as identical. m (multiline): makes ^ match the start of each line and $ match the end of each line, instead of the start and end of the entire string. s (dotAll): makes the dot (.) match any character including newlines (\n), which it normally skips. u (Unicode): enables full Unicode matching, required for \p{} property escapes and correct handling of emoji and supplementary Unicode characters. y (sticky): only matches at the regex's lastIndex position.

How do I match a literal period, asterisk, or other special character?

In regex, many characters have special meaning: . * + ? ^ $ { } [ ] | ( ) \. To match them literally, escape them with a backslash: \. matches a literal period, \* matches a literal asterisk, \( matches a literal opening parenthesis. For example, to match the URL https://example.com, use https://example\.com (escaping the dot) so the dot does not match any character.

What are capture groups and how do I use them?

Capture groups, defined by parentheses (pattern), extract specific parts of a match. For example, the pattern (\d{4})-(\d{2})-(\d{2}) applied to '2024-04-26' creates three capture groups: group 1 = '2024', group 2 = '04', group 3 = '26'. In a replacement string, use $1, $2, $3 to reference these groups—so replacement '$3/$2/$1' would reformat the date to '26/04/2024'. Non-capturing groups (?:pattern) group without creating a capture reference, useful for organizing alternation without the overhead of a capture.

Why is my regex matching too much or too little?

Over-matching is often caused by greedy quantifiers: * and + match as many characters as possible by default. Add ? after the quantifier to make it lazy (match as few as possible): .*? or .+?. Under-matching often results from missing the g flag (only first match found), forgetting to anchor the pattern with ^ and $ when you want a full-string match, or using \d instead of [0-9] when you need to match numeric characters in Unicode mode. Using the real-time highlighter in this tool makes both problems immediately visible.