Regex Pattern Tester & Live Match Highlighter
Test and debug JavaScript regular expressions with live match highlighting, index offsets, capture groups, and common pattern presets.
Unlike conventional calculator sites that send your financial numbers, payload data, or code snippets across remote web servers, Affi-Chain processes all mathematical derivations, algorithms, and data parsing 100% locally within your browser sandbox. No tracking cookies, no server-side retention, and zero transmission lag.
What is Regular Expression Evaluation?
A Regular Expression (Regex) Pattern Tester is an interactive string analysis and diagnostics tool that tests, evaluates, and debugs regular expression patterns against target text corpora in real time. Rooted in theoretical computer science and formal language theory (specifically Non-deterministic Finite Automata, or NFA), regular expressions are the foundational standard for pattern matching, data extraction, input validation, and lexical tokenization across all modern programming languages.
However, authoring regular expressions is notoriously challenging. A single misplaced parenthesis, unescaped dot, or greedy quantifier can subtly alter matching boundaries, allow invalid inputs to bypass security filters, or trigger catastrophic exponential backtracking that locks up CPU execution threads.
The Affi-Chain Regex Pattern Tester provides an instant, 100% in-browser evaluation environment powered by the browser's native JavaScript ECMAScript regex engine. It renders real-time match highlighting, extracts named capture groups, calculates match index offsets, and explains flags with zero server dependencies and complete data privacy.
Regex Tokens & Syntax Anatomy Matrix
A regular expression is composed of literal characters, meta-character tokens, quantifiers, and assertion anchors:
| Token Category | Pattern Syntax | Meaning & Match Behavior | Practical Example |
|---|---|---|---|
| Anchors | ^ and $ | Asserts start (^) and end ($) of string or line | ^[0-9]+$ (Entire string must be digits) |
| Word Boundary | \b | Asserts boundary between a word character and non-word | \bcat\b (Matches "cat" but not "catch") |
| Character Classes | \d / \D | Matches any decimal digit ([0-9]) / non-digit | \d{3}-\d{4} (Phone digits) |
| Alphanumeric | \w / \W | Matches word char ([a-zA-Z0-9_]) / non-word char | \w+ (Identifies variable names) |
| Whitespace | \s / \S | Matches space, tab, newline / non-whitespace | \s+ (Collapses spaces) |
| Any Character | . (Dot) | Matches any character except line breaks (unless s flag) | a.c (Matches "abc", "a-c") |
| Greedy Quantifiers | *, +, ? | Matches 0+, 1+, or 0–1 times (consumes maximum characters) | ".*" (Matches across multiple quotes) |
| Lazy Quantifiers | *?, +? | Matches minimum possible characters | ".*?" (Matches single quoted token) |
| Capture Groups | (...) | Captures matched sub-expression for extraction | (\d{4})-(\d{2}) |
| Named Groups | (?<name>...) | Assigns an identifier key to captured substring | (?<year>\d{4}) |
| Lookaround | (?=...) / (?!...) | Asserts condition ahead without consuming characters | \d+(?= USD) (Matches number before USD) |
Standard Modern Regex Flags
Flags modify how the regex engine scans the string buffer:
| Flag | Name | Operational Engine Behavior |
|---|---|---|
g | Global Search | Retains state across matches; continues scanning rather than stopping after the first match |
i | Case-Insensitive | Evaluates character equivalence regardless of uppercase or lowercase ASCII/Unicode |
m | Multiline Mode | Causes ^ and $ anchors to match the start and end of individual lines (\n) |
s | DotAll Mode | Allows the dot wildcard (.) to match newline characters (\n, \r) |
u | Unicode Mode | Treats string as a sequence of Unicode code points, correctly handling emojis & 4-byte glyphs |
d | Has Indices | Generates start and end array indices for each captured group (match.indices) |
Production-Ready Battle-Tested Patterns
Below are industry-standard patterns for everyday software engineering tasks:
1. Semantic Versioning (SemVer 2.0.0):
^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
2. Strict ISO 8601 UTC Datetime:
^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$
3. Strong Password Policy:
- Minimum 8 characters, at least one uppercase letter, one lowercase letter, one number, and one special character:
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$
Practical Code Implementation: In-Browser Regex Match Engine
Below is a complete JavaScript engine demonstrating match extraction, group indexing, and safety execution:
/**
* In-Browser Regex Execution & Extraction Utility.
*/
function testRegexPattern(patternStr, flagsStr, testString) {
try {
const regex = new RegExp(patternStr, flagsStr);
const matches = [];
if (flagsStr.includes('g')) {
let match;
while ((match = regex.exec(testString)) !== null) {
matches.push({
match: match[0],
index: match.index,
groups: match.groups ? { ...match.groups } : null,
captures: match.slice(1)
});
// Prevent infinite loop on zero-width matches
if (match.index === regex.lastIndex) regex.lastIndex++;
}
} else {
const match = regex.exec(testString);
if (match) {
matches.push({
match: match[0],
index: match.index,
groups: match.groups ? { ...match.groups } : null,
captures: match.slice(1)
});
}
}
return { success: true, count: matches.length, matches };
} catch (err) {
return { success: false, error: err.message };
}
}
// Verification Example (Extracting named date components):
const pattern = "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})";
const input = "Launch dates: 2026-11-18 and 2027-04-12";
const results = testRegexPattern(pattern, "g", input);
console.log("Found matches:", results.matches);
Comparison Matrix: Regex Flavors Across Modern Languages
| Feature | JavaScript (ES2024) | Python (re) | PCRE2 (PHP, C, Apache) | Go (regexp) |
|---|---|---|---|---|
| Engine Architecture | NFA (Backtracking) | NFA (Backtracking) | NFA (Backtracking) | DFA (RE2 Linear Time) |
| Lookbehind Support | Modern (V8, WebKit) | Fixed-width only | Variable-width | Not Supported |
| Named Capture Groups | (?<name>...) | (?P<name>...) | (?<name>...) | (?P<name>...) |
| Possessive Quantifiers | Not Supported | Not Supported | Supported (*+, ++) | Not Supported |
| ReDoS Immunity | Vulnerable | Vulnerable | Vulnerable | Immune (Guaranteed O(N)) |
Critical Edge Cases & Common Regex Traps
1. Catastrophic Backtracking (Regular Expression Denial of Service - ReDoS)
When nested quantifiers are applied to overlapping character sets (e.g., ^([a-zA-Z0-9]+)+$ or (a+)+b), an input string consisting of many 'a's followed by a non-matching character forces the NFA engine to explore every permutation:
$$\text{Execution Steps} = \mathcal{O}(2^n)$$
An input of just 30 characters can freeze a Node.js server thread for over 10 minutes.
- Remediation: Avoid nested quantifiers, utilize atomic grouping where available, and enforce strict input length limits before regex testing.
2. The Unicode Surrogate Pair Trap Without the /u Flag
Characters outside the Basic Multilingual Plane (such as emojis like 🚀 or mathematical symbols) are stored as two 16-bit code units (surrogate pairs).
- Without the
uflag:/^.$/.test('🚀')returnsfalsebecause the dot wildcard matches only one 16-bit code unit, while the emoji consists of two! - With the
uflag:/^.$/u.test('🚀')returnstrue. Always enable theu(Unicode) or modernvflag when processing modern user-generated text.
3. The RegExp.lastIndex Stateful Bug
When a regex is declared globally with the g flag, JavaScript maintains the lastIndex property statefully on the RegExp object itself.
- Evaluating
regex.test("word")twice in a row will returntrueon the first call, butfalseon the second call becauselastIndexwas advanced past the end of the string! - Always reset
regex.lastIndex = 0;before reusing global regex instances.