What does the ^ and $ anchors mean in regex?

^ matches the start of a string (or line in multiline mode), while $ matches the end. So ^hello$ only matches the exact string "hello" with nothing before or after it.

What is the difference between .* and .*? (greedy vs lazy)?

By default, quantifiers like * and + are greedy — they match as much as possible. Adding ? makes them lazy, matching as little as possible. For example, on " " matches " " (greedy) while matches " " (lazy).

What does \b mean in regular expressions?

\b is a word boundary anchor that matches the position between a word character (\w) and a non-word character. For example, \bcat\b matches "cat" in "the cat sat" but not in "concatenate".

How do lookaheads and lookbehinds work?

Lookaheads (?=...) and lookbehinds (?<=...) are zero-width assertions. (?=px) matches a position followed by "px" without consuming it. For example, \d+(?=px) matches numbers followed by "px" like in "16px".

What regex flags are commonly used?

The most common flags are: g (global - find all matches), i (case-insensitive), m (multiline - ^ and $ match line boundaries), and s (dotall - . matches newline). In JavaScript, flags are appended after the closing slash: /pattern/gi.

Regex Cheat Sheet

Interactive regular expression reference with live pattern testing and copy-on-click examples.

Live Tester

Anchors

Pattern	Description	Example
^	Start of string / line	^Hello
$	End of string / line	world$
\b	Word boundary	\bcat\b
\B	Non-word boundary	\Bcat\B
\A	Start of string only	\AHello
\Z	End of string only	world\Z

Quantifiers

Pattern	Description	Example
*	0 or more times	ab*c
+	1 or more times	ab+c
?	0 or 1 time (optional)	ab?c
{n}	Exactly n times	a{3}
{n,}	n or more times	a{2,}
{n,m}	Between n and m times	a{2,4}
*?	Lazy 0 or more	<.*?>
+?	Lazy 1 or more	<.+?>

Character Classes

Pattern	Description	Example
.	Any character except newline	a.c
\d	Digit [0-9]	\d{3}
\D	Non-digit	\D+
\w	Word char [a-zA-Z0-9_]	\w+
\W	Non-word character	\W+
\s	Whitespace	\s+
\S	Non-whitespace	\S+
[abc]	Character set — a, b, or c	[aeiou]
[^abc]	Negated set — not a, b, or c	[^0-9]
[a-z]	Character range	[a-zA-Z]

Groups & Alternation

Pattern	Description	Example
(abc)	Capturing group	(\d+)
(?:abc)	Non-capturing group	(?:ab\|cd)
(?<name>abc)	Named capturing group	(?<year>\d{4})
(?=abc)	Positive lookahead	\d(?=px)
(?!abc)	Negative lookahead	\d(?!px)
(?<=abc)	Positive lookbehind	(?<=\$)\d+
(?<!abc)	Negative lookbehind	(?<!\$)\d+
a\|b	Alternation — a or b	cat\|dog

Flags

Pattern	Description	Example
g	Global — find all matches	/abc/g
i	Case-insensitive	/hello/i
m	Multiline — ^ and $ match line boundaries	/^abc/m
s	Dotall — . matches newline too	/a.b/s
u	Unicode mode	/\u{1F600}/u
y	Sticky — match at exact position	/abc/y

Common Patterns

Pattern	Description	Example
^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$	Email address	user@example.com
https?:\/\/[\w\-._~:/?#[\]@!$&'()*+,;=%]+	URL (http/https)	https://example.com/path
^\+?[1-9]\d{1,14}$	Phone number (E.164)	+12025550123
^\d{4}-(0[1-9]\|1[0-2])-(0[1-9]\|[12]\d\|3[01])$	Date (YYYY-MM-DD)	2024-03-15
^(?:(?:25[0-5]\|2[0-4]\d\|[01]?\d\d?)\.){3}(?:25[0-5]\|2[0-4]\d\|[01]?\d\d?)$	IPv4 address	192.168.1.1
^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$	UUID v4	550e8400-e29b-41d4-a716-446655440000
^#(?:[0-9a-fA-F]{3}){1,2}$	Hex color code	#ff5733 or #f53
^(?=.[a-z])(?=.[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$	Strong password (min 8 chars, upper+lower+digit)	SecureP4ss

Click a pattern to load it into the tester

About this tool

Regular expressions are a powerful pattern-matching language used across programming, data processing, text analysis, and countless applications. Learning regex can feel overwhelming due to its terse syntax and numerous special characters, but understanding the fundamentals—anchors, quantifiers, character classes, groups, and lookarounds—unlocks the ability to solve complex text problems elegantly. This Regex Cheat Sheet brings together the most essential patterns and concepts in one interactive reference.

Simply browse through the curated patterns and concepts grouped by category: anchors (^, $, \b), quantifiers (*, +, ?, {n,m}), character classes ([...], \d, \s), groups and captures (..., ?:...), and lookarounds (positive and negative lookaheads and lookbehinds). The live pattern tester lets you enter your own test string and regex to see matches highlighted in real time. Copy any pattern with a single click and paste it directly into your code or regex debugger.

Bookmark this tool whenever you need a quick refresh on syntax. Whether you're validating email addresses, parsing log files, extracting data from HTML, cleaning up messy strings, or searching code, regex is indispensable. The patterns shown are compatible with most languages (JavaScript, Python, Java, Go, and others), though some advanced features vary slightly across implementations.

Frequently Asked Questions

Code Implementation

import re

# Common regex patterns
email_pattern = r'^[w.-]+@[w.-]+.[a-zA-Z]{2,}$'
url_pattern = r'https?://[w-._~:/?#[]@!$&'()*+,;=%]+'
ipv4_pattern = r'^(?:(?:25[0-5]|2[0-4]d|[01]?dd?).){3}(?:25[0-5]|2[0-4]d|[01]?dd?)$'

# Test email
email = "user@example.com"
if re.match(email_pattern, email):
    print(f"{email} is valid")

# Find all matches
text = "Contact us at info@example.com or support@test.org"
emails = re.findall(r'[w.-]+@[w.-]+.[a-zA-Z]{2,}', text)
print("Found emails:", emails)

# Named groups
date_text = "Today is 2024-03-15"
match = re.search(r'(?P<year>d{4})-(?P<month>d{2})-(?P<day>d{2})', date_text)
if match:
    print(f"Year: {match.group('year')}, Month: {match.group('month')}")

# Substitution
result = re.sub(r's+', ' ', "hello   world   foo").strip()
print(result)  # "hello world foo"

Comments & Feedback

Comments are powered by Giscus. Sign in with GitHub to leave a comment.