Free Regex Tester & Tutorial: Master Regular Expressions Online

What Is a Regular Expression?

A regular expression (regex) is a sequence of characters that defines a search pattern. Think of it as a mini programming language specifically designed for finding, matching, and manipulating text.

Every modern programming language supports regex: JavaScript, Python, Java, Go, Ruby, PHP, C#, Rust. The core syntax is nearly identical across all of them. Learn it once, use it everywhere.

Regex is used for:

• Validating input — checking if an email address, phone number, or URL is properly formatted
• Searching text — finding all occurrences of a pattern in a document or log file
• Extracting data — pulling specific pieces of information out of unstructured text
• Replacing text — performing sophisticated find-and-replace operations
• Parsing logs — extracting timestamps, error codes, and messages from server logs

Getting Started: Literal Matches and Metacharacters

The simplest regex is just plain text. The pattern hello matches the string "hello" wherever it appears. Nothing magical about that.

Things get interesting when you add metacharacters — characters with special meaning in regex:

Try this in the regex tester:

The . matches any single character, so c.t matches "cat", "cot", and "cut" — but not "cart" because there are two characters between "c" and "t".

Character Classes

Character classes let you match any one character from a specific set:

Regex also provides shorthand character classes that you'll use constantly:

Example: To match a US zip code (5 digits), you'd write:

That's it. Five digits. Try it against "My zip is 90210 and yours is 10001" in the regex tester — you'll see both matches highlighted.

Quantifiers

Quantifiers specify how many times the preceding element should appear:

Combining character classes with quantifiers is where regex starts to feel powerful:

Common Patterns You'll Actually Use

Let's build up to real-world patterns. These are the ones developers reach for most often.

Email Validation

A practical email regex that covers the vast majority of valid addresses:

Breaking it down:

• ^ — start of string
• [a-zA-Z0-9._%+-]+ — one or more valid characters in the local part
• @ — literal @ symbol
• [a-zA-Z0-9.-]+ — one or more valid characters in the domain
• \. — literal dot (escaped because . is a metacharacter)
• [a-zA-Z]{2,} — top-level domain with at least 2 letters
• $ — end of string

A word of caution: No regex can fully validate an email address according to the RFC spec. The pattern above handles 99% of real-world addresses. For production systems, send a confirmation email — that's the only true validation.

URL Matching

This matches URLs starting with http:// or https:// (the s? makes the "s" optional) followed by any non-whitespace characters. It's intentionally loose — URLs come in too many shapes for a strict pattern to be practical.

Phone Numbers (US Format)

This handles multiple formats:

• (555) 123-4567
• 555-123-4567
• 555.123.4567
• 5551234567

The \(? and \)? make the parentheses optional. The [-.\s]? allows a dash, dot, space, or nothing between groups.

Date Formats (MM/DD/YYYY or DD-MM-YYYY)

This validates dates with some basic range checking — months 01-12, days 01-31, years 1900-2099. The \b word boundaries prevent matching partial numbers.

IP Addresses (IPv4)

This properly validates each octet from 0 to 255. A simpler but less accurate version would be \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3} — but that would match invalid addresses like 999.999.999.999.

Regex Cheat Sheet

Here's a condensed reference you can come back to. Bookmark this section.

Anchors

Character Classes

Quantifiers

Groups and References

Lookaheads and Lookbehinds

Lookaheads and lookbehinds check for a pattern without including it in the match. For example, \d+(?= dollars) matches the number in "100 dollars" but not the word "dollars" itself.

Groups, Capture, and Extraction

Parentheses do two things in regex: they group elements together, and they capture what they match so you can use it later.

This creates three capture groups:

• Group 1: 2026 (year)
• Group 2: 03 (month)
• Group 3: 28 (day)

In JavaScript, you'd access them like this:

Named capture groups make your code even more readable:

If you just need grouping without capturing (for performance or clarity), use (?:...):

This groups https? and ftp for the alternation, but doesn't create a capture group.

Real-World Use Cases

Data Validation in Forms

Every web form needs input validation. Regex handles the pattern-matching part:

Log Parsing

Server logs follow predictable patterns. Regex can extract structured data from them:

Applied to a log line like 2026-03-28 14:30:05 [ERROR] Database connection timeout, this captures the timestamp, log level, and message as separate groups.

Search and Replace

Regex-powered find-and-replace is one of the most time-saving features in any code editor. For example, converting function calls from one format to another:

This converts console.log("message") to logger.info(message) while handling different quote styles.

Web Scraping and Data Extraction

When parsing HTML or semi-structured text, regex helps extract specific pieces:

This extracts the content between <title> tags. The .*? uses a lazy quantifier — matching as few characters as possible — which prevents it from matching across multiple tags.

For complex HTML parsing, a proper DOM parser is usually better. But for quick extraction tasks, regex is fast and effective.

Tips for Writing Better Regex

1. Start Simple, Then Refine

Don't try to write the perfect pattern on the first attempt. Start with a basic version that matches your target, then add constraints to eliminate false positives.

For matching a date, start with \d{2}/\d{2}/\d{4} before adding range validation for months and days.

2. Use Non-Capturing Groups When You Don't Need the Match

Replace (http|https) with (?:http|https) or even simpler, https?. Unnecessary capture groups waste memory and make your code harder to read.

3. Prefer Lazy Quantifiers for Extracting Content

When extracting content between delimiters, use .*? (lazy) instead of .* (greedy):

4. Use the Right Flags

Most regex engines support flags that change matching behavior:

• g (global) — find all matches, not just the first
• i (case-insensitive) — a matches A
• m (multiline) — ^ and $ match line boundaries, not just string boundaries
• s (dotAll) — . matches newline characters too

5. Comment Complex Patterns

In languages that support the verbose flag (Python's re.VERBOSE, for example), break your regex across multiple lines with comments:

Common Pitfalls and How to Avoid Them

The Greedy Trap

The most common regex bug is greedy matching. Given the text <b>bold</b> and <b>more bold</b>, the pattern <b>.*</b> matches the entire string from the first <b> to the last </b>. Use <b>.*?</b> to match each bold section individually.

Forgetting to Escape Special Characters

Characters like ., *, +, ?, (, ), [, ], {, }, \, ^, $, and | have special meaning. To match them literally, escape with a backslash: \. matches an actual period, \$ matches a dollar sign.

A common mistake: trying to match file.txt with file.txt — the unescaped . matches any character. Use file\.txt instead.

Catastrophic Backtracking

Some regex patterns can take exponentially long to evaluate against certain inputs. This happens when the engine tries too many permutations before failing.

The classic example is (a+)+$ tested against a string like aaaaaaaaaaaaaaaaX. The engine backtracks through billions of combinations before concluding there's no match.

How to avoid it: Don't nest quantifiers (like (a+)+), use atomic groups or possessive quantifiers when available, and always test your patterns against adversarial inputs.

Over-Engineering Validation

You don't need a regex that validates every possible edge case of the email RFC. You need a regex that catches obvious typos and a confirmation email that handles the rest. Perfect is the enemy of good, especially with regex.

Test Your Patterns Interactively

Reading about regex is useful. Practicing it is essential. Our free regex tester lets you:

• Write patterns and see matches highlighted in real time
• View capture groups and their contents
• Test against multiple sample strings
• Switch between regex flavors

For testing regex inside actual code — seeing how patterns behave in JavaScript, Python, Go, or any of 50+ other languages — try our code playground. Write a complete script, run it in the browser, and see the output instantly.

And if you want a structured path from beginner to confident, our Learning Hub offers interactive lessons that build your regex skills step by step, with exercises that reinforce each concept before moving to the next.

From Fear to Fluency

Regular expressions have a reputation for being cryptic, but that reputation comes from people encountering complex patterns before learning the basics. You wouldn't look at advanced calculus and conclude that all math is impossible — you'd start with arithmetic.

The path to regex fluency is straightforward:

1. Learn the building blocks — character classes, quantifiers, and anchors
2. Practice with real patterns — emails, dates, phone numbers, URLs
3. Use a visual tester — watch your pattern match in real time
4. Build gradually — start simple, add complexity only when needed
5. Read other people's patterns — and break them down piece by piece

The patterns in this guide cover the vast majority of what you'll encounter in day-to-day development. Paste any of them into the regex tester, modify them, break them, fix them. That's how fluency happens.

Regular expressions are a skill that pays dividends for your entire career. Every language you'll ever work with supports them. Every codebase you'll ever maintain contains them. The afternoon you spend learning regex today will save you hundreds of hours over the years ahead.