Test and debug regular expressions with real-time matching and highlight.
A regular expression (regex or regexp) is a sequence of characters that defines a search pattern used to find, match, or replace text. Regular expressions are one of the most powerful tools in programming, offering a concise and flexible way to locate and process text patterns. From validating email addresses and phone numbers to parsing log files and extracting data from documents, regex appears everywhere in software development, system administration, and data processing. While the syntax can seem cryptic at first, regular expressions are incredibly efficient for pattern matching tasks that would be tedious or impossible with simple string functions.
Regular expressions use special characters to create patterns. The period (.) matches any single character except newlines. The asterisk (*) means "zero or more" of the preceding element, while the plus sign (+) means "one or more." The question mark (?) means "zero or one" occurrence. Character classes like [a-z] match any single character within the brackets. The backslash escapes special characters, so \. literally matches a period. Anchors like ^ and $ match the beginning and end of a line respectively. The pipe (|) acts as an OR operator. Curly braces {n,m} specify exact repetition counts. Parentheses create capture groups that extract specific parts of matched text. Quantifiers can be made lazy (non-greedy) using ? after them, matching as few characters as possible instead of as many as possible.
Character Classes: [abc] matches a, b, or c. [a-z] matches any lowercase letter. [0-9] or \d matches any digit. [^abc] matches any character except a, b, or c (negation). \w matches any word character (letters, digits, underscore). \s matches any whitespace character (space, tab, newline). \S matches any non-whitespace character.
Email Validation: ^[^\s@]+@[^\s@]+\.[^\s@]+$ — This pattern matches strings containing an @ symbol with characters before and after it plus a domain extension. A more comprehensive email regex would be longer but this covers most valid emails. In practice, email validation via HTTP is more reliable than regex because email rules are complex.
Phone Numbers: \d{3}-\d{3}-\d{4} — Matches US phone format XXX-XXX-XXXX. Variations include \(\d{3}\)\s?\d{3}-\d{4} for parenthesized format like (123) 456-7890.
URLs: https?://[^\s]+ — Matches HTTP or HTTPS URLs followed by non-whitespace characters. This simple pattern catches most URLs, though comprehensive URL validation requires longer expressions.
IPv4 Addresses: \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3} — Matches four numbers separated by periods. For strict validation, you'd verify each number is 0-255.
Hex Color Codes: #[0-9a-f]{6} — Matches six hexadecimal digits after # symbol (with case-insensitive flag, also matches A-F).
Start by entering a regular expression pattern in the "Regular Expression" field. The pattern is case-sensitive by default. Next, enter the text you want to search in the "Test String" field. Select any flags you need: the global (g) flag finds all matches (without it, testing stops at the first match), the case-insensitive (i) flag treats uppercase and lowercase as equivalent, the multiline (m) flag makes ^ and $ match line boundaries instead of just string boundaries, and the dotall (s) flag makes the . metacharacter match newlines. Click "Test Pattern" or let the tool update automatically as you type. The tool displays the number of matches found and capture groups discovered. The "Test String with Highlights" section shows your text with all matching portions highlighted in blue, making it easy to see exactly what was matched. Below that, the "All Matches & Capture Groups" section lists each match with its position and any capture groups extracted from that match. Each capture group is numbered (starting from $1) and shows the exact text it captured.
Form Validation: Regex patterns validate user input before submission. A phone number field might require \d{3}-\d{3}-\d{4} format. A password field might require at least 8 characters with uppercase, lowercase, digits, and special characters: ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$. Validation happens on both client-side (for immediate feedback) and server-side (for security).
Data Extraction: When processing logs, CSV files, or HTML content, regex extracts specific information. For example, extracting timestamps from logs: \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}. Capture groups let you extract multiple parts simultaneously: (\w+)=(\d+) extracts variable names and values from configuration files.
String Replacement: Find and replace operations use regex for pattern-based replacements. Replacing all occurrences of multiple spaces with single spaces: \s+ → (space). Converting between naming conventions: convert camelCase to snake_case using regex replacement patterns. Removing HTML tags: <[^>]+> matches and removes HTML markup.
Search Engine Optimization: Content management systems and search tools use regex to index and search text. Extracting keywords from content, finding URLs in text, identifying phone numbers for automated contact extraction—all use regex patterns.
Programming and Configuration: Code generation tools use regex to parse configuration files. Testing frameworks use regex to match test names. Log aggregation systems use regex patterns to parse and categorize log entries. Sed, awk, and grep commands in Unix systems rely entirely on regex patterns.
Different programming languages implement regex slightly differently, though most follow ECMAScript (JavaScript) or PCRE (Perl-Compatible Regular Expressions) standards. JavaScript's regex engine uses backtracking to match patterns—it tries to match the pattern at each position in the string, backtracking when a dead end is reached. This approach is intuitive but can be inefficient with poorly written patterns. Some patterns cause catastrophic backtracking, where the engine tries exponentially many combinations. For example, (a+)+b against a string of many a's without a b will try every possible grouping before failing, taking exponential time.
Lookahead and Lookbehind: These advanced features match text based on what comes before or after, without including that context in the match. Positive lookahead (?=pattern) matches if pattern follows. Negative lookahead (?!pattern) matches if pattern does not follow. Lookbehind works similarly: (?<=pattern) and (?
Non-capturing Groups and Named Groups: Parentheses create capture groups, but sometimes you want grouping without capturing. Use (?:pattern) for non-capturing groups, which improves performance slightly since the engine doesn't store the matched text. Named groups like (?
Unicode Support: Modern regex engines support Unicode matching. The \p{} syntax matches Unicode character categories. This tool uses JavaScript's native regex support, which handles most Unicode correctly, though some advanced features vary by browser version.
Q: What's the difference between greedy and non-greedy quantifiers?
A: Greedy quantifiers (*, +, {n,m}) match as many characters as possible. Non-greedy versions (*?, +?, {n,m}?) match as few as possible. For example, <.*> on "
Q: Why doesn't my regex match emails correctly?
A: Email validation is surprisingly complex due to RFC 5322 specifications. Simple patterns miss valid emails with subdomains or special characters. The most reliable approach is sending a verification email rather than using regex. If you must validate, use a pattern like ^[^@]+@[^@]+\.[^@]+$ for basic validation.
Q: How do I escape special characters in regex?
A: Use backslash (\) before special characters. \. matches a literal period, \[ matches a literal bracket, \\ matches a literal backslash. In JavaScript strings, you also need to escape the backslash itself, so matching a literal period requires \\. in the string and \. in the regex.
Q: What's the difference between ^ and $ in single-line vs multiline mode?
A: In single-line mode (default), ^ matches only at string start and $ at string end. With the multiline flag (m), ^ matches at the start of any line and $ at the end of any line. This is crucial when processing text with multiple lines separated by newlines.
Q: How do I use capture groups in replacements?
A: Use $1, $2, etc. to reference capture groups in the replacement string. str.replace(/(hello)\s(world)/, "$2 $1") changes "hello world" to "world hello". Named groups use $
Q: Can regex work across multiple lines?
A: Yes, with the dotall (s) flag, the . metacharacter matches newlines. Without it, . matches any character except newlines. Use \n to explicitly match newlines. For complex multiline matching, consider using DOTALL/MULTILINE flags together.
Start Simple: Build regex patterns incrementally. Start with simple patterns and add complexity. Test each addition to ensure it works as expected. This approach catches errors early and makes patterns easier to understand when you return to them later.
Use Raw Strings: In JavaScript, use raw strings (with the r prefix in other languages) to avoid double-escaping. Many regex errors come from escaping confusion between string literals and regex patterns.
Document Complex Patterns: Complex regex patterns become unreadable quickly. Use comments (where supported) or split patterns into multiple steps. Include examples of text that should and shouldn't match. This documentation becomes invaluable when maintaining code months later.
Test with Edge Cases: Don't just test the happy path. Try empty strings, whitespace-only strings, strings with special characters, very long strings, and Unicode characters. Tools like this one make testing edge cases easy—leverage them thoroughly.