Click any item to expand the explanation and examples. Try patterns live with our Regex Tester.
🔤 Character Classes
. (dot) — Any character basics
Matches any single character except newline.
h.t → matches "hat", "hot", "hit", "h9t" .. → matches any two charactersUse
\. to match a literal dot.
\d \w \s — Shorthand classes basics
Built-in character class shortcuts.
\d → digit [0-9] \D → non-digit [^0-9] \w → word char [a-zA-Z0-9_] \W → non-word char \s → whitespace [ \t\n\r\f] \S → non-whitespaceExample:
\d{3}-\d{4} matches "555-1234".
[abc] — Character sets basics
Match any one character in the set.
[aeiou] → any vowel [a-z] → any lowercase letter [A-Z] → any uppercase letter [0-9] → any digit [a-zA-Z] → any letter [^aeiou] → any NON-vowel (^ negates)Example:
gr[ae]y matches "gray" and "grey".
🔢 Quantifiers
* + ? — Basic quantifiers quantifiers
Control how many times a pattern repeats.
* → 0 or more (greedy) + → 1 or more (greedy) ? → 0 or 1 (optional)
colou?r → "color" or "colour" go+gle → "gogle", "google", "gooogle"... ab*c → "ac", "abc", "abbc"...
{n} {n,m} — Exact quantifiers quantifiers
Specify exact repetition counts.
{3} → exactly 3
{2,5} → between 2 and 5
{3,} → 3 or more
\d{3} → "123", "999"
\w{2,4} → 2 to 4 word characters
[a-z]{5,} → 5+ lowercase letters
*? +? ?? — Lazy quantifiers quantifiers
Add
? after a quantifier to make it lazy (match as few as possible).
# Greedy (default): matches as MUCH as possible ".*" on <a>foo</a><b>bar</b> → matches "<a>foo</a><b>bar</b>"Lazy: matches as LITTLE as possible
”.*?” on <a>foo</a><b>bar</b> → matches “<a>” then ”</a>” etc.
⚓ Anchors
^ $ — Start and end anchors
Match positions, not characters.
^hello → line starts with "hello" world$ → line ends with "world" ^exact$ → entire string is "exact"With the
m (multiline) flag, ^ and $ match start/end of each line.
\b — Word boundary anchors
Matches the position between a word character and a non-word character.
\bcat\b → matches "cat" but NOT "category" or "scat" \bpre → matches words starting with "pre" ing\b → matches words ending with "ing"
👥 Groups & Alternation
(abc) — Capturing groups groups
Group patterns and capture matched text.
(foo) → captures "foo" as group 1
(foo)(bar) → group 1: "foo", group 2: "bar"
(\d{3})-(\d{4}) → captures area code and number separately
Reference captured groups with \1, \2 in the pattern or $1, $2 in replacements.
(?:abc) — Non-capturing groups groups
Group without capturing (better performance).
(?:foo|bar)baz → matches "foobaz" or "barbaz"
but doesn't capture "foo"/"bar"
Use when you need grouping for alternation or quantifiers but don't need the captured value.
| — Alternation (OR) groups
Match one pattern or another.
cat|dog → "cat" or "dog" (red|blue) car → "red car" or "blue car" ^(GET|POST|PUT) → line starts with HTTP method
(?<name>) — Named groups groups
Give groups meaningful names.
(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})
In JavaScript:
const m = “2026-03-14”.match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/);
m.groups.year // “2026”
m.groups.month // “03”
\1 \2 — Backreferences groups
Reference a previously captured group within the same pattern.
(\w+)\s+\1 → matches repeated words: "the the", "is is" (["']).*?\1 → matches quoted strings with matching quotes
👀 Lookahead & Lookbehind
(?=...) — Positive lookahead lookaround
Assert what follows, without including it in the match.
\d+(?=px) → matches "12" in "12px" but not "12em" foo(?=bar) → matches "foo" only if followed by "bar"
(?!...) — Negative lookahead lookaround
Assert what does NOT follow.
\d+(?!px) → matches "12" in "12em" but not "12px" foo(?!bar) → matches "foo" NOT followed by "bar"
(?<=...) — Positive lookbehind lookaround
Assert what precedes, without including it in the match.
(?<=\$)\d+ → matches "50" in "$50" but not "50" (?<=@)\w+ → matches username after @ in emails
(?<!...) — Negative lookbehind lookaround
Assert what does NOT precede.
(?<!\$)\d+ → matches "50" when NOT preceded by $ (?<!un)happy → matches "happy" but not "unhappy"
🚩 Flags
g i m s u — Regex flags flags
Modify how the regex engine behaves.
g → global: find all matches, not just the first i → case-insensitive: /hello/i matches "Hello", "HELLO" m → multiline: ^ and $ match line starts/ends s → dotAll: . also matches newline characters u → unicode: enable full Unicode support
# JavaScript
/hello/gi → global + case-insensitive
new RegExp("hello", "gi")
Python
re.findall(r”hello”, text, re.IGNORECASE)
🎯 Common Patterns
Email address patterns
Basic email validation pattern.
[\w.+-]+@[\w-]+\.[\w.]+Matches:
user@example.com, first.last+tag@sub.domain.org
URL patterns
Match HTTP/HTTPS URLs.
https?://[\w\-.]+(:\d+)?(/[\w\-./?%&=]*)?Matches:
https://example.com, http://localhost:3000/path?q=1
Phone number patterns
Common phone number formats.
# US formats
\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}
Matches: (555) 123-4567, 555-123-4567, 555.123.4567, 5551234567
IP address (IPv4) patterns
Match IPv4 addresses.
\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b
Matches: 192.168.1.1, 10.0.0.255
Note: This doesn't validate ranges (0-255). For strict validation, use a more complex pattern or validate in code.
Date (YYYY-MM-DD) patterns
Match ISO date format.
\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])
Matches: 2026-03-14, 2025-12-31
Quick Reference Table
| Pattern | Meaning | Example |
|---|---|---|
. | Any character | h.t → hat, hot |
\d \w \s | Digit, word, space | \d+ → 123 |
[abc] | Character set | [aeiou] → vowels |
[^abc] | Negated set | [^0-9] → non-digit |
* + ? | 0+, 1+, 0 or 1 | go+d → god, good |
{n,m} | n to m times | \d{2,4} → 12, 1234 |
^ $ | Start, end | ^hello$ |
\b | Word boundary | \bcat\b |
(abc) | Capture group | (\d+)px |
(?:abc) | Non-capturing | `(?:a |
a|b | Alternation | cat|dog |
(?=...) | Lookahead | \d+(?=px) |
(?<=...) | Lookbehind | (?<=\$)\d+ |
Try these patterns live → Regex Tester