Regex Tester

Test, debug, and learn regular expressions in real time

Regular Expression

//g

Flags:gGlobaliCase InsensitivemMultilinesDotAll

Test String

Mastering Regular Expressions: The Complete Guide

What Are Regular Expressions?

Regular expressions, commonly abbreviated as regex or regexp, are powerful sequences of characters that define search patterns. They provide a concise and flexible syntax for matching, searching, extracting, and replacing text based on patterns rather than exact literal strings. Regular expressions are supported by virtually every modern programming language, text editor, and command-line tool, making them an indispensable skill for developers, system administrators, data analysts, and anyone who works with text data.

The concept of regular expressions originates from formal language theory and was first implemented in computing by Ken Thompson in the 1960s for use in the QED text editor. Since then, regex has evolved significantly, with modern implementations offering features like lookaheads, lookbehinds, named groups, and Unicode support. Despite their intimidating appearance to beginners, regular expressions follow logical rules and, once mastered, dramatically improve productivity when working with text patterns.

Understanding Regex Syntax Fundamentals

Regular expressions are built from literal characters and metacharacters. Literal characters match themselves exactly: the pattern hello matches the text "hello". Metacharacters have special meanings: the dot (.) matches any single character, the caret (^) matches the start of a string or line, and the dollar sign ($) matches the end. Character classes, defined by square brackets like [abc], match any single character from the specified set. Predefined shorthand classes include \d for digits, \w for word characters, and \s for whitespace.

Quantifiers control how many times an element can repeat: the plus sign (+) means one or more, the asterisk (*) means zero or more, and the question mark (?) means zero or one. Curly braces specify exact counts or ranges, such as {3} for exactly three or {2,5} for between two and five repetitions. By default, quantifiers are greedy, matching as many characters as possible. Adding a question mark after a quantifier (e.g., *? or +?) makes it lazy, matching as few characters as possible. Understanding the difference between greedy and lazy matching is crucial for writing correct patterns that do not overcapture text.

Groups, Capturing, and Backreferences

Parentheses in regular expressions serve two purposes: grouping elements together and capturing matched text. A capturing group like (\d+) both groups the digits and stores the matched text for later use. In the replacement string, you can reference captured groups using $1, $2, and so on. This is incredibly powerful for text transformation, such as reformatting dates from MM/DD/YYYY to YYYY-MM-DD using a pattern like (\d{2})/(\d{2})/(\d{4}) with the replacement $3-$1-$2.

Non-capturing groups, written as (?:...), provide grouping without the overhead of capturing. This is useful when you need to apply a quantifier to a group but do not need to reference the match later. Advanced features like lookaheads (?=...) and lookbehinds (?<=...) allow you to assert that certain patterns exist before or after a match without including them in the result. Negative versions (?!...) and (?<!...) assert the absence of patterns. These zero-width assertions are essential for complex pattern matching, such as matching a word only when it follows a specific prefix or precedes a specific suffix.

Regex Flags and Their Effects

Regex flags (also called modifiers) alter how the pattern engine interprets the expression. The global flag (g) finds all matches rather than stopping after the first one. The case-insensitive flag (i) makes the pattern match regardless of letter case, so /hello/i matches "Hello", "HELLO", and "hElLo". The multiline flag (m) changes the behavior of ^ and $ to match the start and end of each line rather than the entire string, which is essential when processing multi-line text content.

The dotAll flag (s), sometimes called single-line mode, makes the dot (.) character match newline characters as well as all other characters. Without this flag, the dot matches any character except newlines, which can cause unexpected failures when patterns span multiple lines. In JavaScript, additional flags include the Unicode flag (u) for proper Unicode character handling and the sticky flag (y) for anchoring matches at the current position. Choosing the right combination of flags is essential for correct pattern matching, and our tool lets you toggle each flag independently to see their effects in real time.

Common Pitfalls and Best Practices

One of the most common regex mistakes is catastrophic backtracking, where certain patterns cause the regex engine to explore an exponential number of possibilities before failing to match. This typically occurs with nested quantifiers like (a+)+ on input that almost matches. To avoid this, be specific in your patterns, avoid nested quantifiers on overlapping character sets, and use atomic groups or possessive quantifiers when available. Always test your patterns against both matching and non-matching input to ensure acceptable performance.

Other best practices include starting with simple patterns and building complexity incrementally, using comments and named groups for readability in complex expressions, and anchoring patterns with ^ and $ when matching complete strings to prevent partial matches. Be cautious with the dot (.) metacharacter — it often matches more than intended. Prefer specific character classes like [a-zA-Z0-9] when you know exactly which characters are valid. When validating user input, always perform regex validation server-side in addition to client-side, as client-side validation can be bypassed. Our regex tester processes everything in your browser, making it a safe environment to experiment with patterns before deploying them in your applications.

How to Use This Tool

1
Enter your regex pattern
Type your regular expression into the pattern field between the forward slashes. Alternatively, select a preset from the "Common patterns" dropdown to load patterns for emails, URLs, phone numbers, IP addresses, and more.
2
Configure regex flags
Toggle the flags below the pattern field: "g" for global (find all matches), "i" for case-insensitive, "m" for multiline, and "s" for dotAll mode. Click each flag button to enable or disable it.
3
Paste your test string
Enter or paste the text you want to test against in the "Test String" textarea. Matches are highlighted in yellow in real time as you type, and a results table shows each match with its index position and captured groups.
4
Use replace mode (optional)
Click "Show Replace Mode" to expand the replacement section. Enter a replacement string (use $1, $2 for captured groups) and see the transformed result instantly.
5
Review the pattern explanation
Scroll to the "Pattern Explanation" section below to see a breakdown of the regex components in your pattern, including metacharacters, character classes, quantifiers, and groups.
6
Copy your pattern
Click the "Copy" button next to the pattern input to copy the full regex (including delimiters and flags) to your clipboard, ready to paste into your code.

Frequently Asked Questions

Which regex engine does this tool use?▼

This tool uses your browser's native JavaScript RegExp engine. This means the behavior matches exactly what you would get when using regular expressions in JavaScript code, including support for lookaheads, lookbehinds, named groups, and Unicode patterns.

What do the different flags (g, i, m, s) do?▼

The "g" (global) flag finds all matches instead of stopping at the first. The "i" flag makes the pattern case-insensitive. The "m" (multiline) flag makes ^ and $ match line beginnings and endings rather than the whole string. The "s" (dotAll) flag makes the dot (.) also match newline characters.

How do I use captured groups in the replacement string?▼

In replace mode, use $1, $2, $3, etc. to reference the text captured by the first, second, and third parenthesized groups in your pattern. For example, the pattern (\w+)@(\w+) with replacement "User: $1, Domain: $2" would transform "john@example" into "User: john, Domain: example".

Is my test data sent to any server?▼

No. All pattern matching and replacement is performed entirely in your browser using JavaScript. Your test strings and regex patterns never leave your device, making this tool safe to use with sensitive or proprietary data.

Why am I seeing "Invalid regular expression" errors?▼

This typically means the pattern contains a syntax error, such as unmatched parentheses, an invalid quantifier, or an incomplete escape sequence. Check for common issues like missing closing brackets, unescaped special characters that need a backslash, or invalid flag combinations. The error message from the browser engine will usually indicate the specific problem.