Regex Tester: How to Write and Test Regular Expressions

Regular expressions are a miniature programming language for describing patterns in text. They appear in nearly every programming language, in text editors, in command-line tools and in database query systems. The syntax looks cryptic to the uninitiated but follows logical rules that become recognizable with exposure. Understanding regular expressions is one of those skills that pays ongoing dividends every time you work with text data.

The value of being able to write and test regular expressions interactively cannot be overstated. Writing a regex and running it against test data to see what it matches in real time is far more effective than mentally tracing through the pattern logic, which is error-prone even for experienced developers. A regex tester shows you immediately whether your pattern matches what you intended and nothing else, which is often the harder part.

The basic building blocks of regular expressions

Literal characters match themselves. The pattern cat matches the three characters c, a, t in sequence wherever they appear in the target text. Most letters and numbers are literal characters with no special meaning. The characters that do have special meaning are called metacharacters and must be escaped with a backslash if you want to match them literally.

Character classes defined with square brackets match any one character from the set inside the brackets. [aeiou] matches any single vowel. [a-z] matches any lowercase letter. [0-9] matches any digit. The caret inside a character class inverts it: [^0-9] matches any character that is not a digit.

Quantifiers specify how many times the preceding element should match. The asterisk means zero or more times. The plus means one or more times. The question mark means zero or one time. Curly braces with a number specify an exact count: {3} means exactly three times, {2,5} means between two and five times.

Anchors specify position rather than characters. The caret at the start of a pattern anchors it to the start of the line. The dollar sign anchors to the end. The word boundary anchor matches the position between a word character and a non-word character. Using anchors prevents partial matches where you want complete matches only.

Groups and capture

Parentheses create a group, which serves two purposes. First, they allow quantifiers to apply to a sequence rather than just one character. The pattern (ab)+ matches one or more repetitions of the two-character sequence ab. Second, groups capture the matched text for extraction or use in replacements.

Capturing groups are numbered from left to right based on their opening parenthesis position. In a search and replace operation, captured groups are referenced using $1, $2 and so on in the replacement string. This allows you to rearrange parts of matched text. A date like 2024-03-15 can be reformatted to 15/03/2024 using a regex that captures the year, month and day separately and reorders them in the replacement.

Common patterns worth knowing

Email address validation is one of the most commonly attempted regex tasks. The full specification for valid email addresses is complex enough that a truly correct regex is hundreds of characters long and impractical. For most purposes, a pattern that catches obvious non-emails while allowing valid ones is sufficient. A simple pattern that checks for characters before an @, more characters, a dot, and a top-level domain handles the vast majority of real inputs correctly.

Phone number patterns are heavily locale-dependent. A pattern that matches US phone numbers will not match UK numbers. If you need to validate phone numbers, using a library designed for the purpose is more reliable than a regex unless you are working with numbers from a known single locale and format.

Extracting specific data from structured text is where regular expressions genuinely shine. Pulling all URLs from a document, extracting all numbers from a text, finding all occurrences of a specific tag pattern in HTML, and normalizing inconsistent date formats are all tasks that take a few lines of regex and would take many more lines of character-by-character parsing code.

Flags and their effects

Most regex implementations support flags that modify matching behavior. The case-insensitive flag makes the pattern match regardless of letter case. The global flag finds all matches in the target rather than stopping at the first one. The multiline flag changes how start and end anchors behave, making them match at line boundaries rather than only at the start and end of the entire string.

Using the wrong flags accounts for a surprising number of regex bugs. A pattern that works correctly on single-line input may fail on multi-line input if the multiline flag is not set. A case-sensitive pattern that should match case-insensitively produces no matches on correctly spelled input with different capitalization. Testing with the flags set correctly from the beginning prevents these issues.

Open the Regex Tester below.
Enter your regular expression pattern in the pattern field.
Paste your test text in the input area.
Matches highlight in real time as you type.
Adjust the pattern until it matches exactly what you intend.

💡 Test your regex against both text that should match and text that should not. A pattern that matches what you want is only half the job. The other half is making sure it does not match things you did not intend.

Test and debug your regular expressions with live highlighting and match details.

Lookaheads and lookbehinds

Lookahead and lookbehind assertions match a position rather than actual characters. A positive lookahead written as (?=pattern) matches a position that is immediately followed by the pattern. A negative lookahead written as (?!pattern) matches a position not followed by the pattern. These allow you to match something only when it is followed or not followed by something else, without including the something else in the match.

For example, matching a price amount only when followed by a currency symbol, or matching a word only when it is not followed by a specific suffix, requires a lookahead. The matched text does not include the lookahead portion, which makes it useful for extracting just the part you need while using the surrounding context as a condition.

Lookbehinds work the same way but look at what comes before the match position. A positive lookbehind (?<=pattern) matches a position immediately preceded by the pattern. These are less universally supported across different regex implementations than lookaheads, so checking compatibility with your specific language or tool is worth doing before relying on them.

Regex performance and catastrophic backtracking

Most regex patterns run efficiently even on large inputs. However, certain pattern constructions can cause exponential slowdown on specific inputs, a problem called catastrophic backtracking. Patterns that use nested quantifiers on overlapping character classes are the most common cause. A pattern like (a+)+ or (.+)* applied to a long string of characters followed by something the pattern cannot match causes the regex engine to try an exponentially large number of combinations before concluding there is no match.

The practical risk of catastrophic backtracking is higher in server-side code that processes user-supplied input than in developer tools where the input is controlled. Regex denial-of-service attacks deliberately supply inputs that trigger catastrophic backtracking in vulnerable patterns. Testing your patterns against adversarial inputs that include long strings of repeated characters followed by a non-matching character helps identify this vulnerability before it reaches production.

Rewriting vulnerable patterns to avoid nested quantifiers on overlapping classes typically resolves the issue. Atomic groups and possessive quantifiers, supported in some regex implementations, prevent the backtracking entirely by making certain match decisions final. Understanding which regex features are available in your specific language and using them appropriately produces both correct and efficient patterns.

Named capture groups for readable patterns

Named capture groups give meaningful labels to captured portions of a match instead of referring to them by position number. The syntax (?P<name>pattern) in Python, or (?<name>pattern) in JavaScript, creates a capture group accessible by name rather than index. In a regex that captures date components, naming the groups year, month and day makes the code that uses the match results much easier to read than accessing group 1, group 2 and group 3.

Learning regular expressions efficiently

Regular expressions have a reputation for being difficult to learn, which is partly deserved. The syntax is compact and the rules interact in non-obvious ways. The most effective approach is to learn by solving real problems with real data rather than studying the syntax in the abstract. Starting with simple patterns that solve actual problems you face builds practical understanding faster than memorizing the full specification.

Interactive regex testers are the best learning environment because they show you immediately what your pattern matches as you type. The feedback loop of writing a pattern, seeing what it matches, adjusting it and seeing the result changes is what builds intuition for how the rules work. Reading about regex rules without this immediate feedback is much slower and produces less durable understanding.