What are the most common regex patterns I should know?

Email: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/. URL: /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b/. Phone (US): /^$?\d{3}$?[-.\s]?\d{3}[-.\s]?\d{4}$/. Date (YYYY-MM-DD): /^\d{4}-\d{2}-\d{2}$/. IP address: /^(\d{1,3}\.){3}\d{1,3}$/. Hex color: /^#?([0-9A-Fa-f]{6}|[0-9A-Fa-f]{3})$/. Username (alphanumeric): /^[a-zA-Z0-9_]{3,16}$/. Password (min 8, 1 upper, 1 lower, 1 digit): /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$/. This tool includes common patterns library for quick testing.

What are regex flags and when should I use them?

Flags modify regex behavior, added after closing delimiter (/pattern/flags). Common flags: g (global) - find all matches, not just first. i (ignore case) - case-insensitive matching (A = a). m (multiline) - ^ and $ match line breaks, not just string start/end. s (dotall) - . matches newlines. u (unicode) - proper unicode character handling. y (sticky) - match at exact position. Example: /test/gi finds all "test", "TEST", "Test" occurrences. Without g, stops after first match. Use g for find-all, i for case-insensitive, m for multi-line text. This tool supports all major flags with real-time preview.

How do I use capture groups and backreferences in regex?

Parentheses () create capture groups to extract matched portions. Example: /(\d{3})-(\d{3})-(\d{4})/ in "555-123-4567" captures "555", "123", "4567" as groups 1, 2, 3. Backreferences reuse captured groups: \1, \2 refer to first, second group. Example: /(\w+)\s\1/ matches repeated words ("the the"). Named groups: /(? \d{3})-(? \d{3})/ creates named captures. Non-capturing groups: /(?:abc)+/ groups without capturing (faster). Use cases: swap date formats, find duplicate words, extract structured data. JavaScript: match()[1], replace("$1-$2"). This tool highlights capture groups and shows extracted values.

What is the difference between greedy and lazy quantifiers?

Quantifiers (* + {n,m}) are greedy by default - match as much as possible. Example: / / on " text " matches entire string (greedy). Lazy (non-greedy) quantifiers add ? after quantifier - match as little as possible. Example: / / matches " ", then " " separately. Greedy: .* (zero or more, greedy), .+ (one or more, greedy), .{2,5} (2-5, greedy). Lazy: .*? .+? .{2,5}?. Use lazy for: HTML tag extraction, avoiding over-matching, parsing nested structures. Use greedy for: full line matching, whole word extraction. This tool shows greedy vs lazy behavior with match highlighting.

How do I validate email addresses with regex?

Basic email regex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/ (allows most valid emails). Comprehensive: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/ (stricter). Validation challenges: RFC 5322 spec is complex (allows quoted strings, comments), international domains (unicode characters), new TLDs (.museum, .technology), plus addressing (user+tag@domain.com). Best practice: use simple regex for UI validation, send confirmation email for real verification. Don't over-restrict (user@domain.co is valid). This tool tests email patterns against real examples and highlights match groups for debugging custom patterns.

What are lookaheads and lookbehinds (regex assertions)?

Assertions match position, not characters. Positive lookahead (?=pattern) - matches if followed by pattern. Example: /\d(?= dollars)/ matches "5" in "5 dollars" but not "5 euros". Negative lookahead (?!pattern) - matches if NOT followed by pattern. Positive lookbehind (?<=pattern) - matches if preceded by pattern. Example: /(?<=\$)\d+/ matches "100" in "$100". Negative lookbehind (?<!pattern). Use cases: password validation (must contain uppercase: (?=.*[A-Z])), extract values after labels, match words except in quotes. Browser support: lookbehind added in ES2018. This tool tests all assertion types with position highlighting.

How do I debug regex that isn't matching what I expect?

Common issues: escaping special characters (. * + ? [ ] ( ) { } ^ $ | \) - use backslash \. Forgetting anchors - /test/ matches "testing" (use ^test$ for exact match). Wrong flags - case sensitivity (add i flag). Greedy vs lazy - .* vs .*?. Character class mistakes - [a-Z] is wrong (use [a-zA-Z]). Debugging steps: start simple, add complexity incrementally. Test with online tool (this tool!). Use verbose mode if available. Check documentation for your regex flavor (JavaScript vs Python vs PCRE differ). Test edge cases. Use visualization tools. This tool provides live highlighting, match explanation, and error messages for syntax issues.

Home/Tools/Developer/Regular Expression Tester

Regular Expression Tester

Test and debug regular expressions (regex) with real-time matching, syntax highlighting, and detailed explanations. Supports JavaScript, Python, and PCRE flavors.

100% Private - Runs Entirely in Your Browser

No data is sent to any server. All processing happens locally on your device.

Loading Regular Expression Tester...

Regular Expression Pattern

Test String

Global (g)

Case Insensitive (i)

Multiline (m)

Loading interactive tool...

JavaScript Required

This interactive tool requires JavaScript to function. Please enable JavaScript in your browser to use the full features.

The tool description and documentation above provide information about this tool's capabilities. For the best experience, please enable JavaScript and refresh the page.

Complex Parsing Requirements?

From log analysis to data extraction, our developers build reliable parsing solutions at scale.

Learn About Software Development Get Free Consultation

What Is Regular Expression Testing

A regular expression (regex) tester allows you to write, test, and debug regex patterns against sample text in real time. Regular expressions are a powerful pattern-matching language used across virtually all programming languages, text editors, command-line tools, and databases. They match strings based on patterns rather than literal values—enabling search, validation, extraction, and replacement operations that would be impractical with simple string methods.

Despite their power, regular expressions have a notoriously steep learning curve. A single misplaced quantifier or forgotten escape character can cause a pattern to match nothing, match too much, or run catastrophically slowly. A regex tester provides instant visual feedback—highlighting matches, showing capture groups, and explaining pattern behavior—transforming regex development from trial-and-error into an interactive process.

How Regular Expressions Work

Regular expressions define patterns using a combination of literal characters and metacharacters:

Metacharacter	Meaning	Example	Matches
.	Any character (except newline)	a.c	abc, a1c, a-c
*	Zero or more of preceding	ab*c	ac, abc, abbc
+	One or more of preceding	ab+c	abc, abbc (not ac)
?	Zero or one of preceding	colou?r	color, colour
\d	Any digit [0-9]	\d{3}	123, 456
\w	Word character [a-zA-Z0-9_]	\w+	hello, var_1
\s	Whitespace	\s+	spaces, tabs, newlines
^	Start of string/line	^Hello	Hello at line start
$	End of string/line	world$	world at line end
[abc]	Character class	[aeiou]	Any vowel
(group)	Capture group	(\d{4})	Captures 4 digits
(?:group)	Non-capturing group	(?:https?)://	Matches but doesn't capture
\|	Alternation (OR)	cat\|dog	cat or dog

Common regex patterns:

Use Case	Pattern	Matches
Email (basic)	[\w.+-]+@[\w-]+.[\w.]+	[email protected]
IPv4 address	\d{1,3}(.\d{1,3}){3}	192.168.1.1
Date (ISO)	\d{4}-\d{2}-\d{2}	2024-01-15
URL	https?://\S+	https://example.com/path
Phone (US)	(?\d{3})?[-.\s]?\d{3}[-.\s]?\d{4}	(512) 555-0100

Common Use Cases

Input validation: Verify that form fields match expected formats (email, phone, postal code)
Log parsing: Extract timestamps, IP addresses, and error codes from log files
Data extraction: Pull structured data from unstructured text (scraping, ETL)
Search and replace: Transform text patterns across files (rename variables, reformat dates)
Security: Write detection rules for IDS/IPS, SIEM, and WAF systems

Best Practices

Test with both matching and non-matching inputs — A regex that matches everything you want might also match things you don't
Use non-greedy quantifiers when appropriate — .*? instead of .* prevents over-matching in patterns with multiple delimiters
Anchor patterns when validating — Use ^ and $ to ensure the entire string matches, not just a substring
Avoid catastrophic backtracking — Nested quantifiers like (a+)+ can cause exponential processing time; use atomic groups or possessive quantifiers
Comment complex patterns — Use the verbose/extended flag (x) to add whitespace and comments to long regex patterns

References & Citations

MDN Web Docs. (2024). Regular Expressions. Retrieved from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions (accessed January 2025)
Jeffrey Friedl. (2006). Mastering Regular Expressions. O'Reilly Media. Retrieved from https://www.oreilly.com/library/view/mastering-regular-expressions/0596528124/ (accessed January 2025)

Note: These citations are provided for informational and educational purposes. Always verify information with the original sources and consult with qualified professionals for specific advice related to your situation.

Frequently Asked Questions

Common questions about the Regular Expression Tester

Regular expression (regex) is a pattern-matching language for searching and manipulating text. Uses special characters like . (any character), * (zero or more), + (one or more), ? (optional), [] (character class), () (group). Common uses: validate email/phone formats, extract data from logs, find/replace in code editors, parse URLs, sanitize user input, search documents, split strings. Example: /\d{3}-\d{2}-\d{4}/ matches SSN format 123-45-6789. More powerful than simple string search but harder to read. Use for complex patterns; use indexOf() for simple exact matches. This tool tests patterns with live highlighting.