What do the g, i, m, and s regex flags mean?

g (global) finds every match instead of stopping at the first. i makes matching case-insensitive. m (multiline) makes ^ and $ match the start and end of each line rather than only the start and end of the whole string. s (dotAll) makes the . metacharacter also match newline characters, which it does not by default.

What is a capturing group and how is it different from a non-capturing group?

Parentheses around part of a pattern, like (\w+), create a capturing group — the matched substring is extracted separately and available afterward. Use (?:...) for a non-capturing group when you need parentheses for grouping or applying a quantifier but do not want that substring extracted.

How do I match a literal dot, parenthesis, or other special character?

Escape it with a backslash: \. matches a literal period, \( matches a literal opening parenthesis, and \\ matches a literal backslash. Forgetting to escape a metacharacter is one of the most common sources of regex bugs.

Why is my pattern matching more text than I expected?

This is almost always greedy quantifier behavior. .* and .+ consume as much text as possible before backtracking to satisfy the rest of the pattern, so a pattern like ".*" against a string with two quoted phrases can span from the first quote to the very last quote in the string. Use the lazy versions, .*? and .+?, to match as little as possible instead.

What is the difference between .*? and .*?

Both use the same lazy-quantifier syntax; the difference in behavior comes from what quantifier the ? is modifying. Appending ? to any quantifier (*, +, {n,m}) makes it lazy — it matches the minimum needed rather than the maximum, backtracking forward only as necessary to let the rest of the pattern succeed.

Why does my regex with ^ and $ only match the first line of a multiline string?

By default, ^ and $ anchor to the very start and end of the entire input string, not each line. Enable the m (multiline) flag to make them match the start and end of every individual line instead.

What is a lookahead and does JavaScript support it?

A lookahead, written (?=...) for positive or (?!...) for negative, asserts that a pattern does or does not follow the current position without consuming those characters as part of the match. JavaScript has supported lookaheads since ES3 and lookbehinds, (?<=...) and (?<!...), since ES2018 — both work in this tester.

How do named capture groups work?

Use (? ...) to create a group you can reference by name instead of numeric index, for example (? \d{4})-(? \d{2}). This tester shows named groups alongside numbered ones in the captured-groups list, making patterns with several groups much easier to read.

Why does my pattern work in this tester but fail in Python or another language?

Regex syntax is not fully portable between languages. JavaScript, Python (re module), PCRE, and POSIX regex have real differences — for example Python uses (?P ...) for named groups instead of JavaScript's (? ...), and some flavors handle Unicode, word boundaries, or backreferences differently. Since this tool uses the native JavaScript engine, always double-check patterns destined for a non-JavaScript codebase against that language's own regex documentation.

All ToolsRegex Tester

Regex Tester

Test and debug regular expressions. Highlights all matches and shows captured groups.

ilovedocstools.com

Regex Tester

Processing…

Processed on your device

What is Regex Tester?

Regex Tester is a free online tool for writing, testing, and debugging regular expressions against sample text in real time. Enter a pattern and see every match highlighted inline, with a live match count and each captured group's value broken out separately, so you can confirm exactly what your expression does before it goes into production code.

Regular expressions are compact and powerful, and that compactness is exactly what makes them so easy to get subtly wrong. A quantifier without a bound (like + instead of {1,4}) can match far more than intended; an unescaped special character (a literal . or ( that should have been \. or \() silently changes what the pattern matches; and greedy quantifiers by default consume as much text as possible, so .*" in a pattern meant to grab one quoted string can jump all the way to the last quote in the line instead of stopping at the first one. None of these mistakes throw an error — the regex still runs, it just matches the wrong thing, and that kind of silent failure is far more expensive to track down after the fact than a syntax error would be.

This tool exists for the iteration loop that precedes shipping a pattern: type a candidate expression, see immediately what it matches against representative input, adjust, repeat — all without re-running a script, restarting a server, or adding a temporary console.log to a codebase. It supports the full set of JavaScript regex flags: g (global, find every match instead of stopping at the first), i (case-insensitive matching), m (multiline, so ^ and $ anchor to line boundaries instead of only the start and end of the whole string), and s (dotAll, so . also matches newline characters, which it does not by default). Each flag can be toggled independently so you can see exactly how adding or removing one changes the match set.

Capturing groups — the parenthesized parts of a pattern — are extracted and listed separately for every match, which is often the fastest way to spot a group that is capturing the wrong span, an off-by-one in a nested group, or a group you meant to make non-capturing with (?:...) but forgot to.

Everything runs on the native JavaScript RegExp engine built into your browser — the same V8-based engine that runs in Node.js and Chrome — so a pattern that works here will behave identically once you copy it into actual application code. There is no server call and no data transmission, which matters because regex testing frequently involves pasting in real log lines, API responses, or database rows that you would rather not send to a third-party server.

How It Works

You supply a pattern and select which flags to apply (g, i, m, s). The tool constructs a native JavaScript RegExp object from those inputs and runs matchAll() against your test string, which returns every match along with its index and captured groups in one pass. The result renderer then walks through the test string and wraps each matched span in a highlight, leaving non-matching text untouched, so the highlighted output visually mirrors exactly what matchAll() found. Captured groups from every match are flattened into a single list showing which match and group index each value belongs to. If the pattern itself is invalid JavaScript regex syntax, the RegExp constructor throws, and that native error message is surfaced directly so you know precisely what to fix rather than guessing.

How to Use

1
Enter your regex pattern
Type or paste a regular expression into the pattern field, without the surrounding slashes — those are shown for you automatically.
2
Select flags
Toggle g, i, m, and/or s depending on whether you need global matching, case-insensitivity, multiline anchors, or newline-matching dots.
3
Enter your test string
Type or paste the actual text you want to match against — real sample data gives far more useful results than a made-up example.
4
Run the test
Click "Test Pattern" to see every match highlighted directly in the test string, plus the total match count.
5
Inspect captured groups
Scroll to the Captured Groups list to confirm each parenthesized part of your pattern is extracting exactly the substring you expect.
6
Iterate on the pattern
Adjust the pattern or flags and re-run the test until the highlighted matches and captured groups exactly match your intent, then copy the pattern into your code.

Who Uses This Tool

🔍

Pattern Validation

Test email, phone, or URL validation patterns against real input samples before using them in code.

📋

Log File Parsing

Develop and refine patterns for extracting specific fields from server log lines or error messages.

🔄

Find and Replace Logic

Verify a replacement pattern works correctly on sample text before applying it to a large file.

🧪

Form Input Validation

Build and test regex constraints for form fields like credit card numbers, ZIP codes, or usernames.

🛠️

Data Scraping Rules

Iterate on extraction patterns for web scraping scripts to ensure they capture the right tokens.

📚

Learning Regular Expressions

Use the match highlighting and group display to interactively learn how regex flags and syntax work.

Why Choose This Tool

Real-Time Match Highlighting

Matches are highlighted in yellow directly in the test string as you type, giving instant visual feedback.

Captured Group Display

All capturing groups are listed with their match index and value so you can verify extraction logic.

Flag Selection

Toggle g, i, m, and s flags individually so you can test each combination without editing the pattern.

Match Count Badge

Shows the total number of matches at a glance, making it easy to confirm your pattern is inclusive or exclusive enough.

Clear Error Reporting

Invalid regex patterns show a descriptive error message immediately rather than silently producing wrong results.

Privacy by Design

All pattern testing runs in the browser so sensitive log data and proprietary text never leaves your machine.

Also Try

JSON Formatter JS Beautifier Base64 Encode/Decode URL Encode/Decode Word Counter Text Case Converter

Key Benefits

Highlights every match inline against your actual test string
Live match count and per-match captured group values
Supports the full JavaScript flag set: g, i, m, and s
Native error messages surface exact regex syntax problems
100% client-side — sensitive log lines and data never leave your browser
Uses the same V8 RegExp engine as Node.js and Chrome for accurate results
Cheatsheet panel for quick syntax reference without leaving the page
No installation, account, or command line required

Frequently Asked Questions

Also Known As

regex tester online freetest regular expression onlinejavascript regex tester browseronline regex matcher with highlightingregex pattern tester toolregular expression debugger onlinetest regex with capture groupslive regex tester no install