Regex Cheatsheet

Start of string / line

Pattern: ^Hello → matches "Hello world"

End of string / line

Pattern: world$ → matches "Hello world"

Word boundary

Pattern: \bcat\b → matches "the cat sat" (not "concatenate")

Non-word boundary

Pattern: \Bcat\B → matches "concatenate" (not standalone "cat")

Start of string (Python/PCRE)

Pattern: \AHello → matches "Hello world"

End of string (Python/PCRE)

Pattern: world\Z → matches "Hello world"

Any character except newline

Pattern: h.t → matches "hat", "hit", "hot"

Digit

Pattern: \d+ → matches "42" in "abc42"

Equivalent to [0-9]

Non-digit

Pattern: \D+ → matches "abc" in "abc42"

Equivalent to [^0-9]

Word character

Pattern: \w+ → matches "hello_123"

Equivalent to [a-zA-Z0-9_]

Non-word character

Pattern: \W+ → matches "!@#" in "hello!@#"

Equivalent to [^a-zA-Z0-9_]

Whitespace

Pattern: a\sb → matches "a b", "a\tb"

Equivalent to [ \t\r\n\f\v]

Non-whitespace

Pattern: \S+ → matches non-space sequences

Character set — matches a, b, or c

Pattern: [aeiou] → matches any vowel

Negated set — anything except a, b, c

Pattern: [^aeiou] → matches any consonant or non-letter

Range — any lowercase letter

Pattern: [a-z]+ → matches "hello"

Range — any uppercase letter

Pattern: [A-Z]+ → matches "HELLO"

Range — any digit

Pattern: [0-9]{4} → matches "2024"

Combined range — any letter

Pattern: [a-zA-Z]+ → matches "hElLo"

Word character (explicit)

Pattern: [a-zA-Z0-9_]+ → matches "foo_123"

0 or more (greedy)

Pattern: a* → matches "", "a", "aaa"

Use *? for lazy

1 or more (greedy)

Pattern: a+ → matches "a", "aaa"

Use +? for lazy

0 or 1 (optional)

Pattern: colou?r → matches "color", "colour"

Use ?? for lazy

Exactly n times

Pattern: \d{4} → matches "2024"

n or more times

Pattern: \d{2,} → matches "12", "1234"

Use {n,}? for lazy

Between n and m times

Pattern: \d{2,4} → matches "12", "123", "1234"

Use {n,m}? for lazy

Lazy quantifiers — match as few as possible

Pattern: <.+?> → matches each individual tag in "<a><b>"

Greedy would match entire string

Capturing group

Pattern: (foo)bar\1 → matches "foobarfoo"

Non-capturing group

Pattern: (?:foo)+ → matches "foofoo"

Groups without capturing to $1

Named capturing group (ES2018+ / PCRE)

Pattern: (?<year>\d{4}) → matches "2024" → groups.year

Backreference by group number

Pattern: (\w+)\s\1 → matches "hello hello"

Named backreference

Pattern: (?<word>\w+)\s\k<word> → matches "hello hello"

Alternation — match a OR b

Pattern: cat|dog → matches "cat" or "dog"

Alternation inside group

Pattern: (yes|no)+ → matches "yes", "noyesno"

Positive lookahead — must be followed by

Pattern: foo(?=bar) → matches "foo" only in "foobar"

Zero-width assertion — doesn't consume characters

Negative lookahead — must NOT be followed by

Pattern: foo(?!bar) → matches "foo" not followed by "bar"

Positive lookbehind — must be preceded by

Pattern: (?<=foo)bar → matches "bar" only in "foobar"

Negative lookbehind — must NOT be preceded by

Pattern: (?<!foo)bar → matches "bar" not preceded by "foo"

Case-insensitive matching

Pattern: /hello/i → matches "hello", "Hello", "HELLO"

JS: /.../i Python: re.I or re.IGNORECASE

Global — find all matches (JavaScript)

Pattern: /\d+/g → matches all number sequences

JS only — Python uses re.findall()

Multiline — ^ and $ match each line

Pattern: /^\w+/m → matches first word of each line

JS: /.../m Python: re.M or re.MULTILINE

Dotall — dot matches newline too

Pattern: /a.b/s → matches "a\nb"

JS: /.../s Python: re.S or re.DOTALL

Unicode mode (JavaScript)

Pattern: /\u{1F600}/u → matches Unicode emoji

Enables Unicode code point escapes

Verbose mode (Python/PCRE) — allow whitespace & comments

Pattern: re.compile(r"""\d{4} # year""", re.X) → matches 4 digits

Ignores unescaped whitespace in pattern

Email address

URL (http or https)

IPv4 address

Date — YYYY-MM-DD

Hex color code

US phone number

URL slug

UUID v4

Semantic version (semver)

JWT token

Strong password (8+ chars, upper, lower, digit, special)

HTML tag with content (non-greedy)

Integer or decimal number

One or more whitespace (replace with single space)

Strip HTML tags

Markdown link — captures text and URL