Question 1

Why use this instead of regex101?

Accepted Answer

regex101 lets you switch PCRE, Python, and Go. This tester is specifically JavaScript, the engine your frontend will run, and the test string never uploads. Use regex101 when you need another dialect. Use this when you need JS + privacy.

Question 2

What is a regular expression (regex)?

Accepted Answer

A regular expression is a small pattern language for describing sets of strings. The pattern `\d{3}-\d{4}` matches any seven-digit number with a hyphen after the third digit. Regex powers find-and-replace in editors, input validation in forms, log parsing, URL routing, lexer tokenization, and a thousand other text-processing tasks. Every modern language has a regex engine, JavaScript's `RegExp`, Python's `re`, Java's `java.util.regex`, Go's `regexp`, Rust's `regex` crate, and they share most of their syntax but differ in capabilities (lookbehind, atomic groups, possessive quantifiers, named groups) and performance characteristics.

Question 3

How does the live regex tester work?

Accepted Answer

Paste your pattern, pick flags (g, i, m, s, u, y, d), and paste a test string. The tester compiles the regex with `new RegExp(pattern, flags)` and runs it against your input, highlighting every match. Capture groups appear in a side panel, by index for unnamed groups (`$1`, `$2`...) and by name for named groups (`(?<year>\d{4})`). Errors (invalid syntax, unsupported features) surface immediately with the engine's diagnostic message. Because it uses the actual JavaScript `RegExp` engine, results are directly applicable to JS/Node/Bun/Deno code, no flavor-translation surprises.

Question 4

What regex flags does this tester support?

Accepted Answer

All standard JavaScript flags: **g** (global, find all matches not just the first), **i** (case-insensitive), **m** (multiline, `^`/`$` match line boundaries instead of string boundaries), **s** (dotAll, `.` matches newlines too), **u** (unicode, full Unicode matching including surrogate pairs, enables `\u{1F600}` and `\p{...}` Unicode property escapes), **y** (sticky, match must start at `lastIndex`), and **d** (hasIndices, ES2022, adds match start/end positions for capture groups). Flag order doesn't matter; `gimsu` and `usmig` are equivalent.

Question 5

How do I test regex for email validation?

Accepted Answer

The unsatisfying truth: **don't use regex to validate emails**. The RFC 5322 grammar is so permissive (comments, IP-literal hosts, quoted local parts, internationalized domains via Punycode) that the 'correct' regex is several thousand characters and still doesn't cover RFC 6531 (UTF-8 in local parts). The pragmatic alternative: `^[^@\s]+@[^@\s]+\.[^@\s]+$` rejects obvious garbage, then send a confirmation email, the only definitive proof an address works is that someone reads mail there. Use the regex for the form's inline 'looks wrong' UX; use the confirmation email for actual validation.

Question 6

What is the difference between greedy and non-greedy regex matching?

Accepted Answer

Greedy quantifiers (`*`, `+`, `?`, `{n,m}`) match **as much as possible** while still allowing the overall pattern to succeed. Non-greedy / lazy quantifiers (`*?`, `+?`, `??`, `{n,m}?`) match **as little as possible**. Classic example: against `textmore`, the greedy pattern `<.*>` matches the entire string (everything from the first `<` to the last `>`), while the lazy pattern `<.*?>` matches `` first, then ``, then ``, then ``. For 'extract content between tags' the lazy form is what you want, but be aware that **regex is the wrong tool for parsing HTML in the first place**. For real HTML, use a DOM parser.

Question 7

How do I escape special characters in regex?

Accepted Answer

Regex metacharacters needing a backslash to match literally: `. * + ? ^ $ { } [ ] | ( ) \`. Plus inside character classes: `- ] \` (and `^` if it's the first character). Inside JS *string* literals you also need to double-escape, so to write the regex `\.` you type `'\.'` (or use a regex literal `/\./` which avoids the double-escape). The cleanest way to embed an arbitrary string as a literal in a regex is the user-defined function: `pattern.replace(/[.*+?^\${}()|[\]\]/g, '\$&')`. Most languages have a built-in for this (Python's `re.escape`, Java's `Pattern.quote`, Rust's `regex::escape`); JavaScript famously doesn't, though Stage 3 proposal `RegExp.escape` is on its way.

Question 8

Is this regex tester compatible with Python regex?

Accepted Answer

Mostly, but there are real differences. **JavaScript uses ECMAScript regex** (ECMA-262 Annex B); **Python uses PCRE-style** (with Python-specific extensions in the `re` and `regex` modules). Shared: character classes, basic quantifiers, alternation, anchors, most groups. Different: Python supports atomic groups `(?>...)` and possessive quantifiers `*+` (JS does not, though both are coming in Stage 3 proposals). Python uses `(?P...)` for named groups, JS standardized on `(?...)` years later and is now closer to the modern convention. Python supports unicode property escapes via the third-party `regex` module; JS supports them natively with the `u` flag. For Python-specific testing, use a Python regex tool or `python -c 'import re; ...'`.

Question 9

What is catastrophic backtracking and how do I avoid it?

Accepted Answer

Catastrophic backtracking is when a regex engine tries an exponential number of paths trying to match before giving up. The classic trigger is **nested quantifiers**: `(a+)+b` against `aaaaaaaaaaaaaaaaaaaa!` (no `b` at the end) forces the engine to try every possible grouping of `a`s, 2^n combinations, before declaring no match. Real-world example: `^(.*?,){10}$` on a 100-character string with 9 commas pegs a CPU core for seconds. **Defenses:** (1) avoid nested quantifiers; (2) make alternatives mutually exclusive (`[^,]+,` instead of `.*?,`); (3) anchor patterns with `^` and `$` so the engine fails fast; (4) use atomic groups or possessive quantifiers where supported; (5) for user-supplied patterns, use a non-backtracking engine like Google's RE2 (V8 doesn't support this; consider RE2.js or rust-regex-wasm). The Cloudflare 2019 outage was a single catastrophic-backtracking regex.

Question 10

What's the difference between capturing and non-capturing groups?

Accepted Answer

**`(pattern)`** captures the match into a numbered group accessible via `$1`, `$2`, etc. (or `match[1]` in JS). **`(?:pattern)`** groups without capturing, used purely for applying quantifiers or alternation to a subpattern. **`(?pattern)`** captures into a named group, accessible via `match.groups.name`. Non-capturing groups are slightly faster and avoid polluting the capture array; use them whenever you don't need the captured substring. Named groups are dramatically more readable than positional ones, `(?\d{4})-(?\d{2})-(?\d{2})` is self-documenting compared to `(\d{4})-(\d{2})-(\d{2})`.

Question 11

What are lookahead and lookbehind assertions?

Accepted Answer

**Zero-width assertions** that check what comes before or after the current position **without consuming characters**. **Positive lookahead** `(?=...)`: match only if followed by `...`. **Negative lookahead** `(?!...)`: match only if **not** followed. **Positive lookbehind** `(?<=...)`: match only if preceded by `...`. **Negative lookbehind** `(?<!...)`: match only if not preceded. Example: `\d+(?=\$)` matches a number only when followed by `$`, but doesn't include the `$` in the match. Lookbehind in JavaScript requires modern engines (V8 since 2018) and historically had length restrictions in other engines (Python required fixed-width lookbehinds until 3.11). Lookarounds are powerful for 'extract X but only in context Y'-shaped problems.

Question 12

How do I match Unicode characters and emoji?

Accepted Answer

Enable the **`u` flag** for full Unicode support. With `u`: surrogate pairs are treated as a single character (so `.` matches a full emoji), Unicode escapes `\u{1F600}` work, and **Unicode property escapes** become available: `\p{Letter}` matches any letter in any script, `\p{Script=Greek}` matches Greek letters, `\p{Emoji}` matches emoji codepoints, `\p{Decimal_Number}` matches digits in any numeric script. For matching a single user-perceived character (a grapheme cluster, which can combine multiple codepoints like an emoji with a skin-tone modifier), use the `v` flag (ES2024) with `\p{RGI_Emoji}`, or use `Intl.Segmenter` instead of regex. Naive `.` without the `u` flag treats emoji as two separate characters and gives you a bad time.

Question 13

What standards does Regex Tester validate against?

Accepted Answer

Regex Tester checks compliance with ECMAScript 2024 (RegExp), Unicode UTS #18.

Question 14

What are the limitations of Regex Tester?

Accepted Answer

Uses the JavaScript (ECMAScript) regex engine only, results differ from PCRE (PHP, Python re), Java, or Go for lookbehind, atomic groups, and recursive patterns. Very long patterns or inputs with catastrophic backtracking risk may freeze the browser tab. Does not support regex replacement with backreferences in the UI, use the match/inspect workflow only. No support for multi-line file-level matching across thousands of lines in a single pass.

Use Case	Pattern	Notes
Numbers	`-?\d+(\.\d+)?`	Includes floats/negatives
ISO Date	`\d{4}-\d{2}-\d{2}`	YYYY-MM-DD format
UUID	`[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}`	Standard 36-char ID
URL	`https?://[^\s]+`	Simple web address

Regex Tester

Privacy note

How to Use Regex Tester

Enter Pattern

Add Test Text

Toggle Flags

Read Matches

Regex Tester: the essentials

Key points

When to use it

Common mistakes

Learn More

Regex Cheatsheet for JavaScript and Python (2026 Edition)

Regex Engine Behavior Comparison: JavaScript vs PCRE vs Python — 12 Patterns That Match Differently

Bundle Analyzer Guide: Identifying and Fixing JavaScript Bloat

What is Regex Tester?

Frequently Asked Questions

Technical Deep Dive

Regex Tester

01 Common Regex Cheatsheet

02 Performance Guardrails

03 When You Need a Regex Tester (and When You Don't)

04 Worked Examples

05 Related Tools

Regex Generator

Regex Cheatsheet

Find & Replace

Runs 100% in your browser

Compare With

AI Regex Generator

You Might Also Need

JSON Formatter

Base64 Encoder

JSONPath Tester

API Response Diff