Test JavaScript regular expressions instantly. Highlight matches, inspect capture groups, preview replacements, and learn patterns.
Tester
Test patterns against sample text, toggle flags, and review results instantly.
JavaScript regex syntax — escape backslashes as \\d.
Flags
$& = full match ·
$1 $2 = captured groups.
Paste any text — emails, logs, URLs, or plain sentences.
Results
Flags
g
Pattern Notes
Looks for digits.
Text Length
0
Match preview
Ready
Replace preview
Add replacement above
Enter a replacement string to see the result here.
Matches
0 items
Captured groups
Waiting
See Digia Engage in action
Quick Answer
Regex, short for regular expression, is a pattern syntax for finding, matching, and validating text. Instead of comparing strings character by character, you describe the shape of the text you want — such as digits, words, email addresses, dates, domains, or repeated structures — and the regex engine finds every occurrence. Regex is used in JavaScript, Python, Java, Go, and virtually every programming language for form validation, log parsing, data extraction, and search-and-replace workflows.
How It Works
Regex testing uses pattern matching to compare a regular
expression against sample text. Flags like g, i, m, s, u, and y change how the engine interprets the pattern. Capture groups
let you extract pieces of each match, while validation catches
malformed syntax before it reaches production code.
This tool runs the JavaScript RegExp engine entirely in the browser, highlights every match, surfaces
syntax errors safely with try/catch, and shows a live replacement preview so you can see
exactly how String.replace()
would transform your text before writing a single line of code.
Common Use Cases
Regular expressions are a daily tool for frontend engineers, backend developers, DevOps, and data engineers.
Email validation
Prototype or inspect email-related patterns before wiring them into forms, signup flows, or contact validation rules.
Form validation
Test username, password, postal code, slug, or input-mask patterns before shipping them to production interfaces.
Find and replace
Confirm what a pattern will match and preview the replacement output before using it in editors, scripts, or codebase-wide workflows.
Log parsing
Extract timestamps, IDs, status codes, and request fragments from multiline log files or debugging output.
Extracting numbers
Capture prices, dates, counters, invoice IDs, and measurements from mixed strings and application content.
URL matching
Check route-like strings, query fragments, domains, and URL structures when building filters, validators, or redirects.
Data cleanup
Use regex to normalize spacing, remove noise, strip formatting, or separate structured values from messy text exports.
Flags Explained
Flags are optional modifiers appended to a regex pattern that
change how the engine evaluates the expression. In JavaScript
you write them after the closing slash: /pattern/flags.
| Flag | Name | Effect |
|---|---|---|
g | Global | Finds all matches instead of stopping after the first. |
i | Ignore case | Ignores the difference between uppercase and lowercase letters. |
m | Multiline | Makes ^ and $ match the start and end of each line. |
s | DotAll | Allows . to match newline characters so patterns can span lines. |
u | Unicode | Enables full Unicode support including \u{} code point escapes. |
y | Sticky | Matches only at the exact lastIndex position, does not advance. |
Best Practices
Keep patterns readable
Smaller, clearer patterns are easier to debug and review than one large, unreadable expression. Break complex patterns into commented parts when the language supports it.
Escape special characters
Characters like ., +, ?, (,
and [ have
special meaning in regex. Escape them with a backslash when you
want a literal character match.
Use anchors strategically
^ and $ prevent partial matches by anchoring to string boundaries. Use
them when validating complete values like an email address or
a postal code.
Avoid catastrophic backtracking
Nested greedy quantifiers like (a+)+ can run exponentially long on certain inputs. Simplify or rewrite
patterns when you notice performance issues with complex strings.
Test edge cases thoroughly
Always test empty strings, multiline input, unexpected symbols, Unicode characters, and near misses — not only the happy path that proves the pattern works in the expected case.
Use non-capturing groups
(?:...) groups expressions for structure or alternation without creating
captured results you do not need, keeping your match array cleaner
and the pattern easier to follow.
Key Facts
These are the concrete facts that make regex an essential skill for every developer working with strings, validation, or text transformation.
How To
Enter a regex pattern in the Pattern field, select the flags you need, and paste your sample text into the tester.
Run the test or let the page update live to see highlighted matches, match count, index positions, and capture group values.
Enter a replacement string to preview how the regex would transform your text, then copy the result or the full pattern.
Use the cheat sheet tab to browse common regex tokens, copy examples, and learn what each operator does.
FAQ
Answers to the most common questions about regular expressions, regex flags, pattern syntax, and how to use this tool.
Regex, short for regular expression, is a pattern language used to search, match, validate, or extract text. Developers use regex for form validation, log parsing, data cleaning, and pattern extraction in JavaScript, Python, Java, and most modern programming languages.
A regex tester is a browser tool that lets you write a regular expression, paste sample text, and see exactly which parts match — with highlighted results, match indexes, and captured group values. It helps you debug and refine patterns before using them in production code.
Type a regex pattern into the Pattern field, choose the flags you need, paste sample text, and run the test. This tool shows highlighted matches in your text, individual match items with index positions, capture group values, and a live replacement preview — all in the browser.
Flags change how a pattern behaves. g finds all matches globally, i makes matching case-insensitive, m changes start and end anchors to work per line, s allows dots to match newlines, u enables Unicode mode, and y enables sticky matching from a specific position.
A regex becomes invalid due to unbalanced parentheses, malformed character classes, invalid escape sequences, or syntax not supported by the JavaScript RegExp engine. This tester catches those errors with try/catch and displays exactly what needs fixing.
Yes. All regex testing runs entirely in your browser using the JavaScript RegExp engine. No pattern or text data is transmitted to any server. It is completely safe to test patterns on sensitive or proprietary content.
Yes. This tester is built around the JavaScript RegExp engine, so results reflect exactly what you would see in frontend JavaScript, Node.js, and modern JavaScript runtimes — including String.prototype.match(), replace(), replaceAll(), and split().
A capture group is a section of a regex wrapped in parentheses. It extracts a specific portion of a match, such as a year from a date or a domain from a URL. In JavaScript, captured groups appear at index 1, 2, and so on in the match result array.
In regex, . matches any single character except a newline, and * means zero or more of the preceding token. Together, .* greedily matches any sequence of characters on a single line, including an empty string. Enabling the s (dotAll) flag extends . to also match newlines.
^ is the start anchor and $ is the end anchor. ^Hello matches 'Hello' only at the very start of the string. world$ matches 'world' only at the end. With the m (multiline) flag, both anchors match the start and end of each individual line.
A practical pattern for testing email-like strings is [\w.+-]+@[\w-]+\.[a-zA-Z]{2,}. For production use, dedicated validation libraries are more reliable, since the full RFC 5321 email specification is too complex to capture completely in a single regex pattern.
Common causes: the g flag is missing when expecting multiple results, anchors (^ or $) are too restrictive, special characters like . or + need escaping for literal matches, or the pattern contains whitespace or encoding that does not match the actual input text.
Yes. In JavaScript, String.prototype.replace() and replaceAll() accept regex as the first argument. Capture groups can be referenced in the replacement string with $1, $2, and so on. This tester shows a live replace preview so you can confirm the output before using it in code.
Yes, regex is case sensitive by default. The pattern /hello/ will not match 'Hello' or 'HELLO'. Adding the i flag disables case sensitivity so /hello/i matches any capitalization of the word.
+ means one or more occurrences of the preceding token. * means zero or more. So \d+ requires at least one digit while \d* allows a match even when there are zero digits. Both are greedy by default and match as many characters as possible.
A positive lookahead (?=...) checks whether a pattern follows the current position without consuming those characters in the match. For example, \w+(?=@) matches a word only if immediately followed by @, but the @ itself is not included in the matched text.
Use a quantifier with braces: {n} matches exactly n occurrences. \d{4} matches exactly four digits. \w{3,8} matches between three and eight word characters. {n,} means at least n occurrences and {,n} means at most n.
Yes. Paste multiline text directly into the sample text area. Use the m flag so ^ and $ match each individual line. Use the s flag (dotAll) if you want . to match newline characters so patterns can span across line boundaries.
TL;DR
This free online regex tester runs your regular expression against sample text using the JavaScript RegExp engine — entirely in your browser. It highlights every match, shows index positions, extracts captured groups, and previews replacement output in real time. No signup. No server. Instant results.