What is the difference between * and + quantifiers?

The * quantifier matches zero or more occurrences, while + matches one or more. For example, \d* matches an empty string or any number of digits, but \d+ requires at least one digit. Use * when the element is optional and + when at least one occurrence is required. The ? quantifier matches zero or one occurrence.

Regex Tester - Free Online Tool

Q: What is a regular expression?

A regular expression (regex) is a pattern that describes a set of strings. It is used for searching, matching, and manipulating text. For example, the pattern \d+ matches one or more digits, [a-z]+ matches one or more lowercase letters, and .* matches any character sequence. Regular expressions are supported in virtually every programming language.

Q: What are regex flags?

Flags modify how a regex pattern is applied. The global flag (g) finds all matches instead of just the first. The case-insensitive flag (i) matches regardless of letter case. The multiline flag (m) makes ^ and $ match the start and end of each line rather than the entire string. Flags can be combined for more flexible matching.

Q: What are capture groups?

Capture groups are portions of a regex pattern enclosed in parentheses. They capture the matched text for later use. For example, (\w+)@(\w+) applied to 'user@host' captures 'user' as group 1 and 'host' as group 2. Capture groups are essential for extracting specific parts of matched text.

Q: Why is my regex not matching?

Common reasons include: forgetting to escape special characters (use \. to match a literal period), not enabling the global flag to find all matches, not enabling case-insensitive mode, incorrect character classes, or quantifier issues. Check that your pattern matches the exact text format and try testing with simpler patterns first.

Enter a regex pattern and test string to see matches highlighted in real time with capture groups and match count.

How to Use the Regex Tester

Enter your regular expression pattern in the pattern field and your test string in the text area below. Matches are highlighted in yellow in real time as you type. The match count updates instantly. If your pattern includes capture groups (parentheses), the captured values are displayed below the match output. Use the flag checkboxes to enable case-insensitive or multiline matching.

Invalid regex patterns are caught gracefully and show an error message instead of crashing. The global flag is always enabled so all matches are found. This tool is invaluable for building and debugging regular expressions before using them in your code. All processing happens in your browser using JavaScript regex engine.

Understanding Regular Expressions

Regular expressions are one of the most powerful tools in programming for text processing. They can validate input formats (emails, phone numbers, URLs), extract data from strings, search and replace text, and parse structured data. While the syntax can be intimidating at first, learning a few basic patterns covers most common use cases.

Common Regex Patterns

The most frequently used patterns include \d for digits, \w for word characters (letters, digits, underscore), \s for whitespace, and . for any character. Quantifiers like + (one or more), * (zero or more), and ? (zero or one) control repetition. Character classes like [a-z] match ranges of characters. Anchors ^ and $ match the start and end of a line. Combining these building blocks creates patterns for virtually any text matching task.

Capture Groups and Extraction

Parentheses in regex create capture groups that extract matched substrings. The pattern (\w+)@(\w+)\.(\w+) applied to an email address captures the username, domain, and TLD as separate groups. Named capture groups using (?<name>pattern) make extractions more readable in code. Non-capturing groups (?:pattern) group without capturing, which is useful for applying quantifiers to multiple alternatives without extracting.

Performance Considerations

Regex performance matters when processing large texts or running patterns in loops. Avoid catastrophic backtracking by minimizing nested quantifiers like (a+)+. Use specific character classes instead of the dot wildcard when possible. Anchor your patterns with ^ and $ when you know the match position. Compile regex patterns once and reuse them rather than creating new regex objects in loops.

Frequently Asked Questions

What is a regular expression?

A pattern describing a set of strings, used for searching, matching, and manipulating text. Supported in virtually every programming language.

What are regex flags?

Flags modify pattern behavior. Case-insensitive (i) ignores letter case. Multiline (m) makes ^ and $ match line boundaries. Global (g) finds all matches.

What are capture groups?

Portions in parentheses that extract matched text. Pattern (\w+)@(\w+) on "user@host" captures "user" and "host" separately.

Why is my regex not matching?

Common issues: un-escaped special characters, missing flags, wrong character classes, or quantifier problems. Try simpler patterns first.

What is the difference between * and +?

The * matches zero or more occurrences (optional). The + requires at least one occurrence. Use * for optional elements, + for required ones.

Regex Tester

Embed This Calculator