What is the difference between greedy, lazy, and possessive quantifiers?

Greedy quantifiers (*, +, {n,}) match as much text as possible while allowing the engine to backtrack if subsequent tokens fail. Lazy (or non-greedy) quantifiers (*?, +?, {n,}?) match as few characters as possible, expanding only when needed to satisfy the remaining expression. JavaScript RegExp does not natively support possessive quantifiers (e.g. *+), but atomic groups can be simulated using lookarounds.

What is Regular Expression Denial of Service (ReDoS) and how does this tool handle it?

ReDoS occurs when a regular expression contains nested or overlapping quantifiers (such as (a+)+ or (a|a)+) evaluated against pathological non-matching input strings, causing catastrophic backtracking with exponential time complexity O(2^n). Our client-side engine executes evaluations with strict iteration and loop guards to protect browser threads from locking up.

What are lookaround assertions and do they consume characters?

Lookaround assertions (positive lookahead (?=...), negative lookahead (?!...), positive lookbehind (?<=...), and negative lookbehind (?<!...)) are zero-width assertions. They verify whether a subpattern matches or does not match at the current position without advancing the regex match cursor or including the matched text in the captured output.

When should I use the 'u' (Unicode) flag in JavaScript?

The 'u' (unicode) flag enables full Unicode code point handling. Without the 'u' flag, JavaScript treats strings as 16-bit code units, causing astral characters (like emojis or mathematical symbols requiring surrogate pairs) to be split into two separate units. The 'u' flag also enables Unicode property escapes such as \p{Letter} or \p{Script=Greek}.

How does substitution and group referencing work in replacement strings?

In regular expression replacements, special dollar-sign tokens reference matched components: '$&' inserts the entire matched string, '$1' through '$99' insert the nth parenthesized capture group, '$ ' inserts the named group match, and '$$' inserts a literal dollar sign.

Utility #24Client-Side JavaScript

Regular Expression Tester & Debugger

Q: What regular expression flavor and engine does this tester use?

This tool executes using your browser's native JavaScript ECMAScript (ES2024+) RegExp engine. It fully supports standard tokens, greedy and lazy quantifiers, lookahead and lookbehind assertions, named capturing groups, and ECMAScript flags (g, i, m, s, u, y).

Q: When should I use the 'u' (Unicode) flag in JavaScript?

The 'u' (unicode) flag enables full Unicode code point handling. Without the 'u' flag, JavaScript treats strings as 16-bit code units, causing astral characters (like emojis or mathematical symbols requiring surrogate pairs) to be split into two separate units. The 'u' flag also enables Unicode property escapes such as \p{Letter} or \p{Script=Greek}.

Q: How does substitution and group referencing work in replacement strings?

In regular expression replacements, special dollar-sign tokens reference matched components: '$&' inserts the entire matched string, '$1' through '$99' insert the nth parenthesized capture group, '$ ' inserts the named group match, and '$$' inserts a literal dollar sign.

Test, debug, and explain regular expressions in real-time. Features ECMAScript flag controls, capturing group inspector, and substitution sandbox. 100% private client-side execution.

Loading Regex Engine...

Recommended Developer Infrastructure

Regex Flags Reference

g (global): Match all occurrences rather than halting at the first.
i (ignore case): Case-insensitive character comparison.
m (multiline): Anchors ^ and $ match line starts and ends.
s (dotAll): Wildcard dot (.) matches newline (\n) characters.
u (unicode): Enables full Unicode code point handling and properties.

Regular Expression Token Quick Reference

Essential ECMAScript regex syntax, character classes, anchors, and quantifiers.

Character Classes

. : Any character except newline
\d : Any digit [0-9]
\D : Any non-digit [^0-9]
\w : Word character [A-Za-z0-9_]
\W : Non-word character
\s : Whitespace [ \t\r\n\f]
\S : Non-whitespace

Quantifiers & Anchors

^ : Start of string / line
$ : End of string / line
\b : Word boundary
* : 0 or more (greedy)
+ : 1 or more (greedy)
? : 0 or 1 optional
{n,m} : Between n and m times

Groups & Lookarounds

(abc) : Capturing group
(?:abc) : Non-capturing group
(?<id>...) : Named group
(?=...) : Positive lookahead
(?!...) : Negative lookahead
(?<=...) : Positive lookbehind
(?<!...) : Negative lookbehind

Preventing Catastrophic Backtracking in Production

When designing regular expressions for backend validation (such as email checking, URL routing, or sanitization filters), avoid nested unbounded quantifiers like (a+)+ or ([a-zA-Z]+)*. When evaluated against non-matching strings, the regex engine explores millions of permutations before failing, blocking the Node.js event loop or web server worker threads. Always anchor expressions where appropriate and utilize mutually exclusive character sets.

Parsing URLs and Query Parameters?

Instead of complex regexes for URLs, parse and percent-encode URI components directly with RFC 3986 compliance.

Launch URL Encoder / Decoder

Analyzing User-Agent Strings?

Parse browser, operating system, rendering engine, and bot crawlers with our specialized User-Agent Analyzer.

Launch User-Agent Analyzer

Frequently Asked Questions About Regular Expressions

Technical answers regarding regex engines, quantifiers, lookaround assertions, and ReDoS prevention.

This tool executes using your browser's native JavaScript ECMAScript (ES2024+) RegExp engine. It fully supports standard tokens, greedy and lazy quantifiers, lookahead and lookbehind assertions, named capturing groups, and ECMAScript flags (g, i, m, s, u, y).