What is a regular expression (regex)?

A regular expression (regex) is a sequence of characters that defines a search pattern. Regex is used for pattern matching within strings, allowing you to find, replace, or validate text based on specific rules. For example, you can use regex to find all email addresses in text or validate phone number formats. Validate emails with our Email Validator .

What is the difference between greedy and lazy matching?

By default, quantifiers like * and + are greedy — they consume as many characters as possible. For the input hello world bye , the pattern .* matches everything from the first to the last . Adding ? after the quantifier makes it lazy ( .*? ), matching the shortest possible string — so .*? correctly captures each tag separately. Test both versions in the pattern field above to see the difference.

How do I test if my regex pattern works?

Enter your regex pattern in the pattern field and your test text in the text area. The tool will highlight all matches in real-time. You can see the number of matches found and extract specific groups. Use the case-sensitive and global flags to control matching behavior. Test against JSON data for API validation.

What are regex flags (i, g, m)?

i = case insensitive (A and a are treated the same), g = global (find all matches, not just first), m = multiline (^ and $ match start/end of each line). You can combine flags like "gi" for global case-insensitive matching.

Can I use this to learn regex?

Yes! This tool provides instant visual feedback showing which parts of your text match your pattern. Experiment with different patterns, see real-time results, and use the quick reference guide to learn regex syntax interactively. Parse URLs with our URL Parser using regex patterns.

Regex Tester & Debugger

Free online regular expression tester with live highlighting, match extraction, and quick reference guide

Regex Pattern

Pattern

global

ignore case

multiline

dotall

unicode

Test String

Quick Reference

digit [0-9]

word char

whitespace

any char

1 or more

0 or more

0 or 1

start/end

Regex Guide

Regex Syntax Fundamentals

Regular expressions are built from a small set of primitives that combine into powerful patterns. Character classes let you match sets of characters: [a-z] matches any lowercase letter, [0-9] any digit, and shorthand classes like \d (digit), \w (word character), and \s (whitespace) cover the most common cases. Negated classes (\D, \W, \S) match everything except those characters.

Quantifiers control repetition: * means zero or more, + means one or more, ? means zero or one, and {n,m} specifies an exact range. By default these are greedy — they match as much as possible. Appending ? makes them lazy (e.g., .*?), matching the shortest possible string.

Anchors assert positions rather than characters: ^ matches the start of a line, $ the end, and \b a word boundary. Groups created with ( ) capture matched text for back-references or extraction, while non-capturing groups (?: ) group without capturing. Alternation with | acts as a logical OR — cat|dog matches either word. Test these building blocks live in the pattern field above.

Common Regex Patterns

Certain validation patterns appear in nearly every codebase, but each comes with important caveats:

Email validation: The commonly cited pattern ^[\w.+-]+@[\w-]+\.[a-zA-Z]{2,}$ covers most addresses but rejects valid edge cases like quoted local parts and IDN domains. For production use, combine a basic regex check with actual delivery verification. See our dedicated Email Validator for RFC 5322-compliant parsing.
URL matching: https?:\/\/[\w.-]+(?:\.[a-zA-Z]{2,})[\/\w._~:?#\[\]@!$&'()*+,;=-]* handles common HTTP(S) URLs, but URLs can contain percent-encoded characters and internationalized domain names that require more nuanced handling. Pair with our URL Parser for full decomposition.
Phone numbers: ^\+?[1-9]\d{1,14}$ follows the E.164 international standard, but real-world inputs include parentheses, dashes, and spaces. A library like libphonenumber is more robust than any single regex.
IPv4 addresses: ^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$ validates the range 0-255 per octet, but does not distinguish private, loopback, or broadcast addresses.

Regex Performance Tips

Catastrophic backtracking is the most dangerous regex pitfall. It occurs when a pattern contains nested quantifiers that create exponential branching — for example, (a+)+$ applied to a string of a's followed by a non-matching character. The engine tries every possible combination of inner and outer repetitions before failing, which can freeze a browser tab or crash a server. Always test edge cases with long non-matching inputs.

Atomic groups ((?>...) in PCRE) and possessive quantifiers (*+, ++) prevent the engine from backtracking into a subexpression once it has matched, eliminating exponential blowup. JavaScript does not natively support possessive quantifiers, but you can often restructure patterns to avoid the need — for instance, using specific character classes instead of .*.

When NOT to use regex: Regular expressions are not suited for parsing nested structures like HTML or JSON. HTML has recursive nesting that is mathematically beyond what regular expressions can describe (it requires a context-free grammar). Use a DOM parser for HTML and JSON.parse() for JSON — then validate the parsed output with our JSON Validator. Reserve regex for flat pattern matching, tokenization, and search-and-replace on well-defined formats.

Regex Tester & Debugger

Regex Pattern

Test String

Quick Reference

Regex Guide

Regex Syntax Fundamentals

Common Regex Patterns

Regex Performance Tips

Frequently Asked Questions

You Might Also Like

Email

URL

JSON

Diff

Regex Pattern

Test String

Quick Reference

Regex Guide

Regex Syntax Fundamentals

Common Regex Patterns

Regex Performance Tips

Frequently Asked Questions