What is a capture group in regex?

A capture group is created by wrapping part of a pattern in parentheses (). It captures the matched text so you can reference it later, either in the same pattern (backreference) or in replacement strings using $1, $2, etc.

How do I match any character in regex?

Use the dot (.) to match any single character except newlines. To match literally any character including newlines, use the 's' flag (dotAll mode) or the pattern [\s\S].

What is the difference between * and + in regex?

The asterisk (*) matches zero or more of the preceding element, while plus (+) matches one or more. For example, 'a*' matches '', 'a', 'aa', etc., but 'a+' requires at least one 'a'.

What is a character class in regex?

A character class is defined with square brackets [] and matches any single character within the brackets. For example, [aeiou] matches any vowel, [0-9] matches any digit, and [^abc] matches any character except a, b, or c.

How do I make a regex pattern case-insensitive?

Add the 'i' flag to your regex. In JavaScript, this looks like /pattern/i. In this tool, simply toggle the 'i' flag button to enable case-insensitive matching.

What is a non-capturing group?

A non-capturing group (?:...) groups parts of a pattern without capturing the match. It's useful when you need grouping for alternation or quantifiers but don't need to extract the matched text.

How do I use regex for find and replace?

Use the Replace mode in this tool. Enter your pattern, test string, and replacement string. Use $1, $2, etc. to insert captured groups. For example, pattern '(\w+)@(\w+)' with replacement '$2-$1' swaps the parts around the @.

What is a lookahead in regex?

A lookahead checks if a pattern exists ahead without consuming characters. Positive lookahead (?=...) asserts that what follows matches the pattern. Negative lookahead (?!...) asserts that what follows doesn't match.

How do I validate an email address with regex?

A common email regex pattern is: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ This matches standard email formats, though perfect email validation is complex due to the full email specification.

Regex Tester & Debugger

Test, debug, and build regular expressions with real-time pattern matching

Use this regex tester to build and debug regular expressions in real-time. See matches highlighted instantly, understand your pattern with our regex explainer, and visualize capture groups. 100% client-side — your data never leaves your browser.

Regular Expression Pattern:

/ /

Test String:

Matches 0

Enter a pattern and test string to see matches

Capture Groups

Capture groups will appear here

Pattern Explanation

Enter a regex pattern to see its explanation

Quick Reference

Anchors

`^`	Start of string/line
`$`	End of string/line
`\b`	Word boundary
`\B`	Not word boundary

Quantifiers

`*`	0 or more
`+`	1 or more
`?`	0 or 1 (optional)
`{n}`	Exactly n times
`{n,m}`	Between n and m

Character Classes

`.`	Any character
`\d`	Digit [0-9]
`\w`	Word char [a-zA-Z0-9_]
`\s`	Whitespace
`[abc]`	Any of a, b, or c
`[^abc]`	Not a, b, or c

Groups & Lookaround

`(abc)`	Capture group
`(?:abc)`	Non-capturing group
`(?=abc)`	Positive lookahead
`(?!abc)`	Negative lookahead
`a\|b`	a or b

Common Regex Patterns

Click any pattern to load it into the regex tester above. These patterns cover common validation and extraction use cases.

Pattern	Description	Category
`^[a-zA-Z0-9._%+-]+@...`	Email address	Validation
`^https?:\/\/...`	URL	Validation
`\b\d{3}[-.]?\d{3}...`	US Phone Number	Extraction
`^\d{4}-\d{2}-\d{2}$`	Date (YYYY-MM-DD)	Validation
`^(?=.[a-z])(?=.[A-Z])...`	Strong Password	Validation
`^\d{1,3}\.\d{1,3}...`	IPv4 Address	Validation
`^#?([a-fA-F0-9]{6}...`	Hex Color Code	Validation
`^[a-zA-Z0-9_-]{3,16}$`	Username	Validation
`^\d{5}(-\d{4})?$`	US ZIP Code	Validation
`^\$?\d+(\.\d{2})?$`	Currency Amount	Validation
`<([a-z]+)[^>]*>...`	HTML Tag with Content	Extraction
`\b[A-Z][a-z]+\b`	Capitalized Words	Extraction
`^-?\d+(\.\d+)?$`	Integer or Decimal	Validation
`\s+`	Whitespace (1+)	Utility
`^[a-z0-9]+(?:-[a-z0-9]+)*$`	URL Slug	Validation
`(['\"])(.*?)\1`	Quoted String	Extraction
`<!--[\s\S]*?-->`	HTML Comment	Extraction
`^\s*$`	Empty/Whitespace Line	Utility
`\b\w+\b`	All Words	Extraction
`(?<=@)\w+`	Domain from Email (lookbehind)	Advanced

Regular Expression Guide

What is a Regular Expression?

A regular expression (regex or regexp) is a sequence of characters that defines a search pattern. Originally developed in theoretical computer science, regex is now a fundamental tool used across programming languages for text processing, validation, and data extraction.

Regular expressions are used everywhere: form validation in web applications, log file analysis, search-and-replace in text editors, data parsing in ETL pipelines, and URL routing in web frameworks.

Understanding Regex Syntax

Literal Characters

Most characters match themselves literally. The pattern hello matches the string "hello" exactly. However, certain characters have special meanings and must be escaped with a backslash to match literally.

Special Characters (Metacharacters)

These characters have special meanings in regex: . ^ $ * + ? { } [ ] \ | ( ). To match them literally, escape with a backslash: \. matches a period, \* matches an asterisk.

Character Classes

Square brackets define a character class that matches any single character within. [aeiou] matches any vowel. Ranges work too: [a-z] matches any lowercase letter, [0-9] matches any digit. Negate with ^: [^0-9] matches any non-digit.

Shorthand Character Classes

Common patterns have shortcuts: \d (digit), \w (word character: letters, digits, underscore), \s (whitespace). Uppercase versions negate: \D (non-digit), \W (non-word), \S (non-whitespace).

Quantifiers

Quantifiers specify how many times the preceding element should match:

* — Zero or more times (greedy)
+ — One or more times (greedy)
? — Zero or one time (optional)
{n} — Exactly n times
{n,} — n or more times
{n,m} — Between n and m times

Add ? after any quantifier to make it lazy (non-greedy): .*? matches as few characters as possible.

Groups and Capturing

Parentheses create groups that can be quantified together and capture their match for later use:

(abc) — Capturing group: matches "abc" and saves it
(?:abc) — Non-capturing group: groups without saving
(?<name>abc) — Named capture group
\1, \2 — Backreferences to captured groups
$1, $2 — References in replacement strings

Lookahead and Lookbehind

Lookaround assertions match a position without consuming characters:

(?=abc) — Positive lookahead: assert "abc" follows
(?!abc) — Negative lookahead: assert "abc" doesn't follow
(?<=abc) — Positive lookbehind: assert "abc" precedes
(?<!abc) — Negative lookbehind: assert "abc" doesn't precede

Example: \d+(?= dollars) matches digits only if followed by " dollars".

Regex Flags

Flags modify how the pattern is interpreted:

g (global) — Find all matches, not just the first
i (case-insensitive) — Ignore letter case when matching
m (multiline) — ^ and $ match line boundaries
s (dotAll) — Dot . matches newline characters too
u (unicode) — Enable full Unicode matching

Regex FAQ — Common Questions Answered

What is a regular expression (regex)?

A regular expression is a pattern that describes a set of strings. It's a powerful tool for searching, matching, and manipulating text. Regex is supported in virtually all programming languages and many text editors.

How do I test a regex pattern?

Enter your pattern in the input field above, then add your test string. Matches will be highlighted in real-time. Toggle the flags (g, i, m, s, u) to adjust matching behavior.

What do the regex flags mean?

g (global) finds all matches; i ignores case; m (multiline) makes ^ and $ match line boundaries; s (dotAll) makes . match newlines; u enables Unicode support.

What is a capture group?

Parentheses () create capture groups that save the matched text. You can reference captured text with $1, $2, etc. in replacements, or use backreferences \1, \2 within the same pattern.

How do I match a literal special character?

Escape special characters with a backslash. For example: \. matches a period, \* matches an asterisk, \\ matches a backslash, \( matches an opening parenthesis.

What is the difference between * and +?

* matches zero or more occurrences (including none), while + requires at least one occurrence. Pattern a* matches "", "a", "aa", but a+ requires at least one "a".

How do I match the start or end of a string?

Use ^ for the start and $ for the end. With the m (multiline) flag, these also match line boundaries within the string.

How do I make my regex case-insensitive?

Enable the i flag. This makes Hello match "hello", "HELLO", "HeLLo", etc. Click the "i" button in this tool to toggle it.

What is a non-greedy (lazy) match?

By default, quantifiers are greedy — they match as much as possible. Adding ? after a quantifier makes it lazy: .*? matches as few characters as possible.

What is a lookahead?

A lookahead checks if a pattern exists ahead without consuming characters. (?=pattern) is positive lookahead (pattern must follow), (?!pattern) is negative lookahead (pattern must not follow).

How do I validate an email with regex?

A common pattern is ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$. Note that perfect email validation is complex; for production use, consider additional validation or using your language's built-in validators.

Is my data safe using this tool?

Yes! This regex tester runs entirely in your browser. Your patterns and test strings are never sent to any server. Everything is processed client-side using JavaScript.