utility calculator

Regular Expression (Regex) Tester & Explainer

Test and debug regular expressions with real-time match highlighting, group capture breakdown, and a handy free cheat sheet.

Formula Verified by Dr. Arthur Pendelton, PhD

Quick actions: Save inputs, view saved runs, print, share, or export results

Saved Runs

Inputs

Interactive Regular Expression Tool

Regular Expression Pattern

Global (g)Case Insensitive (i)Multiline (m)

Test Subject String

Real-Time Highlights

Capture Group & Match Dashboard

Match #1 (idx: 14)

support@example.com

Match #2 (idx: 37)

sales@website.org

Common Regex Tokens Cheat Sheet

Any decimal digit [0-9]

Alphanumeric [a-zA-Z0-9_]

Whitespace (space, tab, newline)

Word boundary anchor

Start of subject string

End of subject string

One or more repetitions

Zero or more repetitions

Results

Tip

Save this page to validate email patterns, replace text structures, and write pattern matching code.

Related guides

Learn more about this calculation

Guide

Understanding Calculator Formulas: How DTC Turns Inputs into Results

Understand how Do The Calculation formulas are presented, what the explanation blocks mean, and how to verify calculator logic before using a result in a real decision.

Site Guide

How to Use Do The Calculation Calculators: A Practical Step-by-Step Guide

Learn the fastest reliable workflow for using Do The Calculation calculators, reading results, checking formulas, and using save, print, share, and export actions correctly.

Inputs

Interactive Regular Expression Tool

Regular Expression Pattern

Global (g)Case Insensitive (i)Multiline (m)

Test Subject String

Real-Time Highlights

Capture Group & Match Dashboard

Match #1 (idx: 14)

support@example.com

Match #2 (idx: 37)

sales@website.org

Common Regex Tokens Cheat Sheet

Any decimal digit [0-9]

Alphanumeric [a-zA-Z0-9_]

Whitespace (space, tab, newline)

Word boundary anchor

Start of subject string

End of subject string

One or more repetitions

Zero or more repetitions

How to understand and use this calculator

Theoretical Foundations of Regular Expressions

Regular expressions (regex) are algebraic formulas used to define search patterns in text. They are built on formal language theory and theoretical computer science. In the Chomsky hierarchy, regular expressions define regular languages, which are parsed using finite automata.

A finite automaton is a mathematical model of computation representing state machines that process input strings character by character, transitioning between states based on predefined rules. There are two primary types of automata:

Deterministic Finite Automata (DFA): Transition from one state to exactly one other state for any input. DFAs are fast, running in linear time O(N) relative to the text length, but do not support advanced regex features like backreferences.
Non-deterministic Finite Automata (NFA): Can transition to multiple states simultaneously or backtrack. Most programming language regex engines (including JavaScript, Python, and Java) use backtracking NFA engines because they support capturing groups and lookaround assertions.

Regex Engine Backtracking and ReDoS Vulnerabilities

Because backtracking NFA engines evaluate multiple paths to find a match, poorly written regex patterns can trigger catastrophic backtracking. This occurs when a pattern has nested quantifiers (such as `(a+)+`) and is evaluated against a string that almost matches but fails at the very end (e.g. `aaaaaab`).

The engine must try every possible combination of grouping the characters to find a match. This leads to exponential time complexity, where the number of execution steps grows as O(2^n), where n is the string length. Attackers exploit this behavior in Regular Expression Denial of Service (ReDoS) attacks to lock up server CPUs. Developers must write patterns that avoid ambiguous nested quantifiers to ensure execution times remain safe.

Grammar and Token Syntax Reference

Understanding regular expression grammar requires learning its core token categories:

Anchors: Specify positions in the string. `^` represents the start of the string, `$` represents the end, and `\b` represents a word boundary.
Character Classes: Match sets of characters. `\d` matches any digit, `\w` matches any word character (letters, numbers, underscore), and `\s` matches whitespace.
Quantifiers: Specify repetition counts. `*` matches zero or more times, `+` matches one or more times, `?` matches zero or one time, and `{min,max}` matches a specific range.
Lookarounds: Zero-width assertions that match patterns without consuming characters. Positive lookahead `(?=...)` asserts a pattern follows, while negative lookbehind `(?<!...)` asserts a pattern does not precede.

Practical Debugging and Performance Optimization

To write high-performance regular expressions, developers should follow these optimization guidelines:

Make quantifiers lazy when appropriate by appending a question mark (e.g. `.*?` instead of `.*`), which stops matching at the first valid delimiter rather than scanning to the end of the text.
Use non-capturing groups `(?:...)` instead of standard capture groups `(...)` if you do not need to extract the submatch data. Non-capturing groups save memory and speed up engine execution.
Compile and cache regex objects in loops instead of redeclaring patterns on every iteration. In JavaScript, declare the `RegExp` instance outside loop scopes to avoid garbage collection overhead.

How to Use This Regex Tester

Type or paste a pattern into the Regular Expression field, then toggle the Global (g), Case Insensitive (i), and Multiline (m) flag checkboxes to match your use case. Enter or paste the text you want to test against in the Test Subject box.

Matches highlight in yellow in the Real-Time Highlights panel, and the Capture Group Match Dashboard on the right lists every match with its string index and any captured groups. Click "Load Date Format Sample" to instantly swap in a YYYY-MM-DD date-matching example.

Worked Example: Matching Email Addresses

The default pattern `[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}` tested against "Contact us at support@example.com or sales@website.org for inquiries." with the g and i flags finds exactly 2 matches: support@example.com and sales@website.org.

Loading the date format sample switches the pattern to `\b\d{4}-\d{2}-\d{2}\b` against "The launch schedule is 2026-06-30 for phase 1 and 2026-07-01 for phase 2." — this also returns 2 matches, 2026-06-30 and 2026-07-01, demonstrating how the same tool handles structurally different patterns.

Related Calculators

This tester is part of a Developer Tools cluster. To validate structured data instead of raw text patterns, use the JSON Formatter Validator. For other web-text transformations, see the URL Encoder Decoder or the Markdown Editor Live Previewer.

Related concepts

Finite automata

Mathematical models of computation representing state machines used to parse regular languages.

Catastrophic backtracking

An execution failure in NFA engines causing exponential evaluations on non-matching inputs.

ReDoS attack

A denial of service exploit targeting regular expression backtracking engines.

Frequently Asked Questions

What is a regular expression (regex)?+

A regular expression is a sequence of characters that forms a search pattern. It is used in programming to validate inputs, search text logs, extract data patterns, and perform bulk search-and-replace actions.

What is the difference between greedy and lazy quantifiers?+

Greedy quantifiers (like * or +) match as much text as possible. Lazy quantifiers (like *? or +?) match the minimum amount of text possible before satisfying the pattern.

What is catastrophic backtracking?+

Catastrophic backtracking occurs in NFA regex engines when a pattern contains overlapping nested quantifiers (like (a+)+). When processing non-matching inputs, the engine tests every permutation, resulting in exponential execution times that freeze CPUs.

What do the g, i, and m flags do in regex?+

The "g" (global) flag searches for all matches in the text rather than stopping after the first match. The "i" flag makes the search case-insensitive. The "m" (multi-line) flag makes the anchors ^ and $ match the start and end of individual lines.

What is the difference between capturing and non-capturing groups?+

Capturing groups "(...)" remember the matched text for later extraction or backreferencing. Non-capturing groups "(?:...)" group elements for quantifiers without saving the match, saving processing time.

How do lookahead and lookbehind assertions work?+

Lookahead "(?=...)" checks if a specific pattern follows the current position, and lookbehind "(?<=...)" checks if a pattern precedes it. They are zero-width assertions, meaning they do not include the checked text in the match.

How do I escape special characters in a regex pattern?+

To match literal special characters (like ., *, +, ?, ^, $, (, ), [, ], {, }, |, \), you must prefix them with a backslash (e.g. use "\." to match a literal period).

Why does my regex behave differently in JavaScript vs Python?+

Different languages use different regex engines (e.g. JavaScript uses ECMA-262, Python uses its built-in re module). While core features are identical, syntax support for advanced lookbehinds and named capture groups varies.

What is a word boundary anchor (\b)?+

A word boundary "\b" is a zero-width assertion that matches the boundary between a word character (letters, digits, underscore) and a non-word character or the start/end of the string.

How can I prevent ReDoS (Regular Expression Denial of Service)?+

To prevent ReDoS, keep patterns simple, avoid nested quantifiers (like repeating groups that contain repeated characters), use timeout limits in your regex engine, and validate input lengths before running regex evaluations.

How to understand and use this calculator

Theoretical Foundations of Regular Expressions

Deterministic Finite Automata (DFA): Transition from one state to exactly one other state for any input. DFAs are fast, running in linear time O(N) relative to the text length, but do not support advanced regex features like backreferences.
Non-deterministic Finite Automata (NFA): Can transition to multiple states simultaneously or backtrack. Most programming language regex engines (including JavaScript, Python, and Java) use backtracking NFA engines because they support capturing groups and lookaround assertions.

Regex Engine Backtracking and ReDoS Vulnerabilities

Grammar and Token Syntax Reference

Understanding regular expression grammar requires learning its core token categories:

Anchors: Specify positions in the string. `^` represents the start of the string, `$` represents the end, and `\b` represents a word boundary.
Character Classes: Match sets of characters. `\d` matches any digit, `\w` matches any word character (letters, numbers, underscore), and `\s` matches whitespace.
Quantifiers: Specify repetition counts. `*` matches zero or more times, `+` matches one or more times, `?` matches zero or one time, and `{min,max}` matches a specific range.
Lookarounds: Zero-width assertions that match patterns without consuming characters. Positive lookahead `(?=...)` asserts a pattern follows, while negative lookbehind `(?<!...)` asserts a pattern does not precede.

Practical Debugging and Performance Optimization

To write high-performance regular expressions, developers should follow these optimization guidelines:

Make quantifiers lazy when appropriate by appending a question mark (e.g. `.*?` instead of `.*`), which stops matching at the first valid delimiter rather than scanning to the end of the text.
Use non-capturing groups `(?:...)` instead of standard capture groups `(...)` if you do not need to extract the submatch data. Non-capturing groups save memory and speed up engine execution.
Compile and cache regex objects in loops instead of redeclaring patterns on every iteration. In JavaScript, declare the `RegExp` instance outside loop scopes to avoid garbage collection overhead.

How to Use This Regex Tester

Worked Example: Matching Email Addresses

Related Calculators

Related concepts

Finite automata

Mathematical models of computation representing state machines used to parse regular languages.

Catastrophic backtracking

An execution failure in NFA engines causing exponential evaluations on non-matching inputs.

ReDoS attack

A denial of service exploit targeting regular expression backtracking engines.

Frequently Asked Questions

What is a regular expression (regex)?+

What is the difference between greedy and lazy quantifiers?+

Greedy quantifiers (like * or +) match as much text as possible. Lazy quantifiers (like *? or +?) match the minimum amount of text possible before satisfying the pattern.

What is catastrophic backtracking?+

What do the g, i, and m flags do in regex?+

What is the difference between capturing and non-capturing groups?+

How do lookahead and lookbehind assertions work?+

How do I escape special characters in a regex pattern?+

To match literal special characters (like ., *, +, ?, ^, $, (, ), [, ], {, }, |, \), you must prefix them with a backslash (e.g. use "\." to match a literal period).

Why does my regex behave differently in JavaScript vs Python?+

What is a word boundary anchor (\b)?+

A word boundary "\b" is a zero-width assertion that matches the boundary between a word character (letters, digits, underscore) and a non-word character or the start/end of the string.

How can I prevent ReDoS (Regular Expression Denial of Service)?+

Regular Expression (Regex) Tester & Explainer

Inputs

Interactive Regular Expression Tool

Capture Group & Match Dashboard

Common Regex Tokens Cheat Sheet

Results

Learn more about this calculation

Understanding Calculator Formulas: How DTC Turns Inputs into Results

How to Use Do The Calculation Calculators: A Practical Step-by-Step Guide

Regular Expression (Regex) Tester & Explainer

Inputs

Interactive Regular Expression Tool

Capture Group & Match Dashboard

Common Regex Tokens Cheat Sheet

Results

Key output metrics

How to understand and use this calculator

Theoretical Foundations of Regular Expressions

Regex Engine Backtracking and ReDoS Vulnerabilities

Grammar and Token Syntax Reference

Practical Debugging and Performance Optimization

How to Use This Regex Tester

Worked Example: Matching Email Addresses

Related Calculators

Related concepts

Frequently Asked Questions

Learn more about this calculation

Understanding Calculator Formulas: How DTC Turns Inputs into Results

How to Use Do The Calculation Calculators: A Practical Step-by-Step Guide

Key output metrics

How to understand and use this calculator

Theoretical Foundations of Regular Expressions

Regex Engine Backtracking and ReDoS Vulnerabilities

Grammar and Token Syntax Reference

Practical Debugging and Performance Optimization

How to Use This Regex Tester

Worked Example: Matching Email Addresses

Related Calculators

Related concepts

Frequently Asked Questions