Matches any single character except newline.

h.t     → matches "hat", "hot", "hit", "h9t"
..      → matches any two characters

Use \. to match a literal dot.

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-whitespace

Example: \d{3}-\d{4} matches "555-1234".

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".

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"...

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

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.

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.

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"

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.

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.

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

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”

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

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"

Assert what does NOT follow.

\d+(?!px)      → matches "12" in "12em" but not "12px"
foo(?!bar)     → matches "foo" NOT followed by "bar"

Assert what precedes, without including it in the match.

(?<=\$)\d+     → matches "50" in "$50" but not "50"
(?<=@)\w+      → matches username after @ in emails

Assert what does NOT precede.

(?<!\$)\d+     → matches "50" when NOT preceded by $
(?<!un)happy   → matches "happy" but not "unhappy"

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)

Basic email validation pattern.

[\w.+-]+@[\w-]+\.[\w.]+

Matches: user@example.com, first.last+tag@sub.domain.org

Match HTTP/HTTPS URLs.

https?://[\w\-.]+(:\d+)?(/[\w\-./?%&=]*)?

Matches: https://example.com, http://localhost:3000/path?q=1

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

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.

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