Regular Expression Tester
Test and debug regular expression patterns with instant match results and replacement functionality
Match Results
No matches found
Match Details
Enter regex pattern and test text to see detailed match information
//
Quick Patterns
Replace Function
Use $1, $2 etc. for capture groups
This sed command can be used in Unix/Linux/macOS terminal or Git Bash on Windows
About Regular Expression Tester
The Regular Expression Tester is a powerful tool for testing and debugging regular expressions in real-time. It provides instant feedback on pattern matching, highlighting matches in your test text and showing detailed match information.
This tool supports all JavaScript regex flags and provides quick access to common patterns. Whether you're validating user input, parsing data, or learning regex syntax, this tester makes the process interactive and visual.
How to Use This Tool
- Select a quick template or enter your regular expression pattern
- Set appropriate flags (g for global, i for ignore case, m for multiline)
- Enter or load sample test text
- View real-time match results and details
- Use replace function to test replacement operations
Key Features
- Real-time regex testing with instant visual feedback
- Support for all JavaScript regex flags (g, i, m, s, u, y)
- Syntax highlighting for matched text
- Detailed match information with groups and positions
- Quick access to common regex patterns
- Copy functionality for matched results
- Multi-line text support with proper formatting
Regular Expression Flags
gGlobal (g)
Find all matches rather than stopping after the first match
iIgnore Case (i)
Case-insensitive matching
mMultiline (m)
^ and $ match line boundaries
Usage Tips
- Use the Global flag (g) to find all matches in your text
- Test your regex with various input samples to ensure accuracy
- Use capturing groups () to extract specific parts of matches
- The Ignore Case flag (i) is useful for case-insensitive searches
- Use \b for word boundaries to match whole words only
- Test edge cases like empty strings and special characters
Common Regular Expression Patterns
Basic Patterns
\dAny digit (0-9)\wWord characters (a-z, A-Z, 0-9, _)\sWhitespace characters.Any character except newlineQuantifiers
+One or more*Zero or more?Zero or one{n}Exactly n timesAnchors
^Line start$Line end\bWord boundaryPractical Examples
Email Validation
[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}Matches common email address formats.
Matches： john.doe@example.com, support@codertools.net
Phone Number (US Format)
\\(?([0-9]{3})\\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})Captures area code, exchange, and number with flexible separators.
Matches： (555) 123-4567, 555.987.6543, 555-123-4567
URL Matching
https?:\\/\\/(www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b([-a-zA-Z0-9()@:%_\\+.~#?&//=]*)Matches HTTP/HTTPS URLs with optional www prefix and paths.
Matches： https://example.com, http://www.site.org/path
Strong Password Validation
^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)[a-zA-Z\\d@$!%*?&]{8,}$At least 8 characters with uppercase, lowercase, and digits.
Matches： Password123, MyStr0ngP@ss
Advanced Features
Capturing Groups
Use parentheses to capture parts for replacement or output.
([0-9]{4})-([0-9]{2})-([0-9]{2})Lookahead / Lookbehind
Match based on surrounding context without consuming it.
(?=.*password)Non-capturing Groups
Group without affecting capture group numbering.
(?:http|https)://sed Command Generation
Generate equivalent sed commands from your regex and replacement text.
Search Mode (Empty Replacement)
When replacement is empty, output only matching lines.
sed -n '/pattern/p' input.txtExample：Pattern: error
Result：Prints all lines containing 'error'
Replace Mode (With Replacement)
When replacement text is provided, generate a replace command.
sed 's/pattern/replacement/flags' input.txtExample：Pattern: foo, Replacement: bar
Result：Replaces all 'foo' with 'bar'
Special characters are escaped automatically. Works in Unix/Linux/macOS terminals and Git Bash on Windows.
Learning Resources
Online Resources
Best Practices
Start simple and iterate
Build patterns gradually instead of writing complex regexes at once.
Prefer non-capturing groups
Use (?:...) when you don't need the capture to keep numbering clean.
Anchor your patterns
Use ^ and $ when appropriate to avoid unintended substring matches.
Use specific character classes
Prefer [a-zA-Z]+ or \\d{3} over .* to reduce backtracking.
Escape special characters
Escape . * + ? [ ] ( ) { } ^ $ \\ | when matching literals.
Test edge cases
Try empty strings, long inputs, and special characters for stability.
Troubleshooting
Why does my pattern match nothing?
Check flags and confirm special characters are properly escaped.
Why does my regex freeze the browser?
Nested quantifiers can cause catastrophic backtracking. Simplify the pattern.
Why do capture groups return unexpected values?
Group numbering starts at 1; group 0 is the full match. (?:...) does not count.
Why does it behave differently across languages?
Regex engines differ. Lookbehind and Unicode support vary by environment.