Regex Tester
Test regular expressions against a string and see all matches highlighted
Pattern
Test string
What is a Regular Expression?
A regular expression (regex or regexp) is a sequence of characters that defines a search pattern. Regex testers let you write a pattern, run it against sample text, and see all matches highlighted in real time. The concept dates back to mathematician Stephen Kleene's work on regular languages in the 1950s, and Ken Thompson built the first regex engine into the QED text editor in 1968.
A regex engine reads a pattern left to right, consuming input characters as it tries to match. It uses backtracking when a partial match fails: the engine steps back and tries alternative paths through the pattern. Some engines (like RE2 used in Go) avoid backtracking entirely by converting patterns to deterministic finite automata (DFA), which guarantees linear-time matching at the cost of not supporting features like back-references.
Regex syntax is standardized loosely. PCRE (Perl Compatible Regular Expressions) is the most common flavor, supported by PHP, Python's re module, and JavaScript with minor differences. POSIX defines a more limited syntax used by grep and sed. The differences matter when porting patterns between languages: a lookahead that works in JavaScript may not compile at all in Go's RE2 engine.
Why Use an Online Regex Tester?
Writing regex in a code file means saving, running, and inspecting output each time you adjust the pattern. A browser-based regex tester closes that feedback loop to zero: you type, you see matches.
Regex Tester Use Cases
Regex Syntax Quick Reference
The table below covers the most-used regex tokens. These work across JavaScript, Python, Go, PHP, and most PCRE-compatible engines. Language-specific extensions (like Python's conditional patterns or JavaScript's named groups with \k syntax) are noted in the code examples section.
| Pattern | Name | Description |
|---|---|---|
| . | Any character | Matches any single character except newline (unless s flag is set) |
| \d | Digit | Matches [0-9] |
| \w | Word character | Matches [a-zA-Z0-9_] |
| \s | Whitespace | Matches space, tab, newline, carriage return, form feed |
| \b | Word boundary | Matches the position between a word character and a non-word character |
| ^ | Start of string/line | Matches the start of the input; with m flag, matches start of each line |
| $ | End of string/line | Matches the end of the input; with m flag, matches end of each line |
| * | Zero or more | Matches the preceding token 0 or more times (greedy) |
| + | One or more | Matches the preceding token 1 or more times (greedy) |
| ? | Optional | Matches the preceding token 0 or 1 time |
| {n,m} | Quantifier range | Matches the preceding token between n and m times |
| () | Capturing group | Groups tokens and captures the matched text for back-references |
| (?:) | Non-capturing group | Groups tokens without capturing the matched text |
| (?=) | Positive lookahead | Matches a position followed by the given pattern, without consuming it |
| (?<=) | Positive lookbehind | Matches a position preceded by the given pattern, without consuming it |
| [abc] | Character class | Matches any one of the characters inside the brackets |
| [^abc] | Negated class | Matches any character not inside the brackets |
| | | Alternation | Matches the expression before or after the pipe |
Regex Flags Explained
Flags (also called modifiers) change how the engine processes the pattern. In JavaScript you append them after the closing slash: /pattern/gi. In Python you pass them as a second argument: re.findall(pattern, text, re.IGNORECASE | re.MULTILINE). Not all flags are available in every language.
| Flag | Name | Behavior |
|---|---|---|
| g | Global | Find all matches, not just the first one |
| i | Case-insensitive | Letters match both uppercase and lowercase |
| m | Multiline | ^ and $ match start/end of each line, not just the whole string |
| s | Dot-all | . matches newline characters as well |
| u | Unicode | Treat the pattern and subject as a Unicode string; enables \u{FFFF} syntax |
| y | Sticky | Matches only from the lastIndex position in the target string |
Code Examples
Working regex examples in JavaScript, Python, Go, and the command line. Each example shows pattern construction, match extraction, and output.
// Match all email addresses in a string
const text = 'Contact us at support@example.com or sales@example.com'
const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g
const matches = text.matchAll(emailRegex)
for (const match of matches) {
console.log(match[0], 'at index', match.index)
}
// β "support@example.com" at index 14
// β "sales@example.com" at index 37
// Named capture groups (ES2018+)
const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
const result = '2026-03-30'.match(dateRegex)
console.log(result.groups)
// β { year: "2026", month: "03", day: "30" }
// Replace with a callback
'hello world'.replace(/\b\w/g, c => c.toUpperCase())
// β "Hello World"import re
# Find all IPv4 addresses
text = 'Server 192.168.1.1 responded, fallback to 10.0.0.255'
pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
matches = re.findall(pattern, text)
print(matches) # β ['192.168.1.1', '10.0.0.255']
# Named groups and match objects
date_pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
m = re.search(date_pattern, 'Released on 2026-03-30')
if m:
print(m.group('year')) # β '2026'
print(m.group('month')) # β '03'
# Compile for repeated use (faster in loops)
compiled = re.compile(r'\b[A-Z][a-z]+\b')
words = compiled.findall('Hello World Foo bar')
print(words) # β ['Hello', 'World', 'Foo']package main
import (
"fmt"
"regexp"
)
func main() {
// Find all matches
re := regexp.MustCompile(`\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b`)
text := "Contact support@example.com or sales@example.com"
matches := re.FindAllString(text, -1)
fmt.Println(matches)
// β [support@example.com sales@example.com]
// Named capture groups
dateRe := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`)
match := dateRe.FindStringSubmatch("2026-03-30")
for i, name := range dateRe.SubexpNames() {
if name != "" {
fmt.Printf("%s: %s\n", name, match[i])
}
}
// β year: 2026
// β month: 03
// β day: 30
// Replace with a function
result := re.ReplaceAllStringFunc(text, func(s string) string {
return "[REDACTED]"
})
fmt.Println(result)
// β Contact [REDACTED] or [REDACTED]
}# Find lines matching an IP address pattern
grep -E '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' access.log
# Extract email addresses from a file
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' contacts.txt
# Replace dates from YYYY-MM-DD to DD/MM/YYYY using sed
echo "2026-03-30" | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/'
# β 30/03/2026
# Count matches per file in a directory
grep -rcE 'TODO|FIXME|HACK' src/
# β src/main.js:3
# β src/utils.js:1