Regex Tester

What a Regular Expression Actually Is

A regular expression is a compact pattern language for describing sets of strings. Instead of writing procedural code to scan text character by character, you declare a pattern and let the engine find every substring that fits. Regular expressions power search-and-replace, input validation, log parsing, syntax highlighting, and tokenization. In JavaScript they are first-class objects created with a literal like /\d+/g or with the RegExp constructor.

This tester uses the browser's own engine, so what you see is exactly what your application code will do with the same pattern, flags, and input.

The Six Flags and What They Change

• g (global): find every match instead of stopping at the first. Without it, only the first match is returned.
• i (ignore case): treat upper and lower case as equivalent, so /abc/i matches "ABC".
• m (multiline): make ^ and $ match the start and end of each line, not just the whole string.
• s (dotall): let . match newline characters, which it does not by default.
• u (unicode): enable correct handling of code points beyond the basic plane and Unicode property escapes like \p{L}.
• y (sticky): anchor matching to the engine's lastIndex, useful for tokenizers that must match contiguously.

Capture Groups and Backreferences

Parentheses create capture groups, numbered left to right by their opening bracket. The pattern (\w+)@(\w+) captures the local part and domain of a simple address into groups 1 and 2. Named groups, written (?<year>\d{4}), let you reference captures by name instead of position, which keeps complex patterns readable. Non-capturing groups (?:…) group without consuming a numbered slot, which matters when you only need grouping for an alternation or quantifier.

In replacements you reference captures with $1, $2, or $<name>. The token $& inserts the whole match, and $$ inserts a literal dollar sign. The Substitution panel in this tool previews exactly how those tokens expand.

Greedy vs Lazy Quantifiers

By default, quantifiers like *, +, and {2,} are greedy: they match as much as possible, then backtrack if needed. Appending ? makes them lazy, matching as little as possible. The classic trap is <.*> against <a><b>, which greedily matches the whole string in one go. The lazy version <.*?> matches each tag separately. Watching the highlight update as you add the ? makes the difference obvious.

Common Pitfalls

• Forgetting to escape special characters: a literal dot, plus, or parenthesis must be written \., \+, \(. An unescaped dot matches any character.
• Catastrophic backtracking: nested quantifiers like (a+)+ on certain inputs can take exponential time. Prefer specific patterns and possessive-style constructs where possible.
• Assuming . matches newlines: it does not unless you set the s flag. Multiline text often needs both m and s depending on intent.
• Reusing a global regex object: a /g RegExp carries lastIndex between calls, which can cause skipped matches if you reuse the same object across loops.
• Validating with regex alone: some formats, like email addresses or HTML, are notoriously hard to validate fully with a single expression. Use regex for a first-pass shape check, then verify semantically.

Where Regex Fits and Where It Does Not

Regular expressions excel at lexical pattern matching: extracting tokens, validating shapes, and find-and-replace. They are a poor fit for parsing recursively nested structures such as balanced parentheses, full HTML, or JSON, where a real parser is the right tool. Knowing the boundary saves hours: reach for regex on flat patterns, and switch to a parser when the grammar nests.

A Practical Debugging Workflow

The most effective way to build a complex pattern is incrementally. Start with the simplest expression that matches part of your target, confirm it highlights what you expect, then add one constraint at a time. If a match disappears unexpectedly, the last token you added is the culprit — remove it and reconsider. Use the capture-group columns to verify that each group isolates the right fragment, and keep the test string varied: include the edge cases you actually care about, such as empty fields, trailing whitespace, and unexpected characters. Because every change re-runs instantly and entirely in your browser, you can iterate dozens of times in a minute without ever sending your data anywhere. This tight feedback loop, more than memorizing syntax, is what turns regex from a source of bugs into a dependable tool you reach for with confidence.