Regex Tester

Related

What is a Regular Expression (Regex/RegExp)?

Use Cases

• Testing form validation rules online — verify email, phone, ID number, URL regexes work correctly
• Log analysis — using regex to extract timestamps, error messages, IP addresses from ERROR/INFO level logs
• Data cleaning/ETL — preview regex replace effects, e.g. date format conversion, sensitive data masking (phone middle digits asterisked)
• Web scraping — verify content extraction regexes accurately match target HTML fragments or JSON fields
• Learning regex — understand metacharacters and quantifiers through the "Explain" panel, get started quickly with templates
• Code Review — share questionable regexes via link with colleagues for collaborative debugging and optimization

How to Use

1. Enter your regex pattern in the input box between / / (no need to add slashes yourself), enter flags on the right (e.g. g, gi, gim) or toggle using the buttons below
2. Paste or type text to match in the "Test Text" area — match results will be color-highlighted in real time
3. Click the "Match Details" panel on the right to see each match's position, content, Capture Groups and Named Groups
4. Switch to the "Replace" tab, enter a replacement string (supports $1/$&/$<name> references), preview replacement results in real time
5. Switch to the "Pattern Explain" tab to view auto-generated element-by-element regex syntax explanation
6. When you need common templates, click "Template Library" on the left to select and fill instantly; after debugging, click "Share" to generate a link

Features

• Web Worker sandbox execution: Regex runs in an isolated Worker thread with 500ms timeout auto-interrupt, completely preventing ReDoS browser freezes
• Real-time matching + color highlighting: Match results appear instantly as you type, different matches highlighted in 5 colors, hover links to detail panel
• Capture Groups + Named Groups: Each match automatically expands to show all Capture Groups ($1/$2) and Named Groups ($<name>), with summary statistics
• Replace preview: Enter a replacement string to see real-time preview, supports $1/$&/$`/$'/$<name> syntax with quick buttons
• Regex syntax explanation: Automatically parses regex patterns and explains metacharacters, quantifiers, groups, anchors element by element
• 12 common templates: Built-in high-frequency regex templates for email/URL/phone/Chinese/IPv4/UUID/date/log/HTML tags, fill with one click
• 6 flag toggles: g/i/m/s/u/y flag visual toggle buttons, no need to memorize syntax
• Share links: One-click generate URL containing pattern/flags/text, copy to colleagues to reproduce exact test state
• Execution statistics: Real-time display of match count, execution time (ms), total Capture Groups, Named Group count
• 1500 match limit: Auto-truncate to prevent page lag from extremely long text, friendly syntax error hints for invalid regex

Code Examples

// Validate email format
const emailRe = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
console.log(emailRe.test('user@example.com')); // true

// Extract Named Groups (date parsing)
const dateRe = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;
const text = 'Meeting: 2026-03-12, Deadline: 2026-04-01';
const matches = [...text.matchAll(dateRe)];
for (const m of matches) {
  console.log(m.groups.year, m.groups.month, m.groups.day);
}

// Replace: date format conversion YYYY-MM-DD → MM/DD/YYYY
const reformatted = text.replace(dateRe, '$<month>/$<day>/$<year>');
console.log(reformatted);
// Meeting: 03/12/2026, Deadline: 04/01/2026

import re

# Find all matches
text = 'Contact: alice@example.com, bob@test.org'
emails = re.findall(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', text)
print(emails)  # ['alice@example.com', 'bob@test.org']

# Named Group extraction (Python uses ?P<name> syntax)
date_pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
m = re.search(date_pattern, 'Published on 2026-03-12')
if m:
    print(m.group('year'), m.group('month'), m.group('day'))

# Replace: mask middle 4 digits of phone number
phone_re = r'(1[3-9]\d)\d{4}(\d{4})'
result = re.sub(phone_re, r'\1****\2', 'Phone: 13812345678')
print(result)  # Phone: 138****5678

import java.util.regex.*;

class RegexDemo {
    public static void main(String[] args) {
        String text = "Error [2026-03-12 18:05:09] Connection failed";

        // Compile regex (cache Pattern instances in production)
        Pattern p = Pattern.compile(
            "(?<level>INFO|WARN|ERROR)\\s+\\[(?<time>[^\\]]+)\\]\\s+(?<message>.+)"
        );
        Matcher m = p.matcher(text);

        if (m.find()) {
            System.out.println("Level: " + m.group("level"));
            System.out.println("Time: " + m.group("time"));
            System.out.println("Message: " + m.group("message"));
        }

        // Replace all digits
        String cleaned = "abc123def456".replaceAll("\\d+", "*");
        System.out.println(cleaned); // abc*def*
    }
}

FAQ

Glossary

Regex / RegExp

Short for Regular Expression, a string syntax describing text matching patterns used for searching, replacing, and validating text.

Capture Group

A subexpression wrapped in parentheses (pattern), match results can be referenced by position via $1, $2.

Named Group

A Capture Group defined with the (?<name>pattern) syntax, can be referenced by name via $<name>, offering better readability than numeric references.

ReDoS

Regular Expression Denial of Service, where catastrophic backtracking causes exponential regex execution time, freezing browsers or servers.

Backtracking

The mechanism where NFA regex engines fall back to previous positions to try alternatives when a match attempt fails; complex patterns can cause exponential backtracking.

Flags

Parameters that modify regex matching behavior; common ones are g(global), i(ignore case), m(multiline), s(dotAll), u(Unicode), y(sticky).

Lookaround

Zero-width assertions including positive lookahead (?=...), negative lookahead (?!...), positive lookbehind (?<=...), negative lookbehind (?<!...), which check position without consuming characters.

PCRE

Perl Compatible Regular Expressions, a widely used regex syntax standard adopted by PHP, Java, Python, and most other languages.

Web Worker

A browser API providing background threads separate from the main thread; this tool uses it to execute regex in a Worker so ReDoS doesn't block the UI.

Quantifier

Syntax specifying how many times the preceding element repeats: *(0 or more), +(1 or more), ?(0 or 1), {n}(exactly n), {n,m}(n to m times).

Regex Metacharacter Quick Reference

Common Regex Template Quick Reference

Authoritative References

• MDNMDN: RegExp Official Documentation
• WikipediaRegular Expression - Wikipedia
• OWASPOWASP: ReDoS Attack Protection Guide