Regex Cheat Sheet

Searchable regular expression reference, syntax cheat sheet, and interactive test playground.

Interactive Test Playground

6 matches found

Pattern

Flags (g, i, m, s)

Sample String

Matches:quickbrownjumpsoverlazydogs

Anchors

Pattern	Description	Example
^	Start of string (or line in multiline mode)	^Hello matches 'Hello world'
$	End of string (or line in multiline mode)	world$ matches 'Hello world'
\b	Word boundary	\bcat\b matches 'cat' but not 'catch'
\B	Non-word boundary	\Bcat matches 'scat'
\A	Start of string (no multiline)	\AHello
\Z	End of string (no multiline)	world\Z

Character Classes

Pattern	Description	Example
.	Any character except newline	a.c matches 'abc', 'a1c'
\d	Digit [0–9]	\d+ matches '42'
\D	Non-digit	\D+ matches 'abc'
\w	Word character [A-Za-z0-9_]	\w+ matches 'hello_42'
\W	Non-word character	\W+ matches ' '
\s	Whitespace (space, tab, newline)	\s+ matches ' '
\S	Non-whitespace	\S+ matches 'word'
[abc]	Character set — any of a, b, or c	[aeiou] matches vowels
[^abc]	Negated character set	[^aeiou] matches consonants
[a-z]	Character range	[a-z] matches any lowercase letter
[a-zA-Z]	Case-insensitive range	[a-zA-Z]+ matches 'Hello'

Quantifiers

Pattern	Description	Example
*	Zero or more (greedy)	a* matches '', 'a', 'aaa'
+	One or more (greedy)	a+ matches 'a', 'aaa'
?	Zero or one (optional)	colou?r matches 'color', 'colour'
{n}	Exactly n times	\d{3} matches exactly 3 digits
{n,}	n or more times	\d{2,} matches 2+ digits
{n,m}	Between n and m times	\d{2,4} matches 2–4 digits
*?	Zero or more (lazy)	a*? is non-greedy
+?	One or more (lazy)	<.+?> matches shortest tag
??	Zero or one (lazy)	colou??r — prefer no 'u'

Groups & Alternation

Pattern	Description	Example
(abc)	Capture group — captures match	(\d+) captures digits
(?:abc)	Non-capturing group	(?:https?://)\S+
(?P<name>abc)	Named capture group	(?P<year>\d{4})
a\|b	Alternation — a or b	cat\|dog matches 'cat' or 'dog'
\1	Backreference to group 1	(\w+)\s+\1 matches repeated words

Lookahead & Lookbehind

Pattern	Description	Example
(?=abc)	Positive lookahead — followed by	\d(?=px) matches digit before 'px'
(?!abc)	Negative lookahead — not followed by	\d(?!px) digit NOT before 'px'
(?<=abc)	Positive lookbehind — preceded by	(?<=\$)\d+ number after '$'
(?<!abc)	Negative lookbehind — not preceded by	(?<!\$)\d+ not after '$'

Flags

Pattern	Description	Example
g	Global — find all matches (not just first)	/\d+/g
i	Case-insensitive match	/hello/i matches 'HELLO'
m	Multiline — ^ and $ match line boundaries	/^start/m
s	Dotall — . matches newline too	/a.b/s matches 'a\nb'
u	Unicode — enables Unicode escapes	/\u{1F600}/u
y	Sticky — match at lastIndex only	/\d+/y
d	Indices — report match indices	/\d+/d

Special & Escape

Pattern	Description	Example
\n	Newline	line1\nline2
\t	Tab	col1\tcol2
\r	Carriage return	\r\n (Windows line ending)
\uXXXX	Unicode code point	\u0041 matches 'A'
\xHH	Hex code point	\x41 matches 'A'
\0	Null character	\0 (byte 0x00)
\\	Literal backslash	C:\\path matches 'C:\path'

Visible Patterns

Active Category

all

Playground Status

6 Matches

Regular expression cheat sheet & reference

This regular expression reference sheet categorizes regex syntax elements including anchors, character classes, quantifiers, capture groups, lookarounds, and flags. Click any pattern's play icon to test it live inside the built-in browser regex evaluator.

To test complex regular expressions against multi-line text, visit our dedicated Regex Tester. To escape special characters in regex strings, try the Regex Escape Tool.

Built and maintained by Meet Shah · Last updated 19 July 2026

What this tool is used for

Finding the syntax for a construct you use rarely.
Checking what a flag changes before adding it.
Learning lookahead and lookbehind syntax with examples.
Confirming what a shorthand character class actually includes.
Finding the right quantifier for a case.

Frequently Asked Questions

What is the difference between greedy and lazy quantifiers?: Greedy matches as much as possible then backtracks; lazy stops at the first opportunity. `<.*>` swallows a whole line of HTML where `<.*?>` matches one tag — the most common surprise for newcomers.
When should I use a non-capturing group?: Whenever you group for alternation or repetition but do not need the text. `(?:...)` keeps the capture numbering clean and avoids storing matches you will never read.
What are lookahead and lookbehind for?: Asserting context without consuming it — matching a word only when followed or preceded by something. Lookbehind support was historically patchy, though it is now available in modern JavaScript, Python and .NET.
Why does my regex hang on a long input?: Catastrophic backtracking — nested quantifiers such as `(a+)+` produce exponential paths on a near-match. It is a real denial-of-service vector, and the fix is to make the pattern unambiguous rather than to add a timeout.
Do regex flavours really differ that much?: Enough to matter. Word boundaries, Unicode property support, named group syntax and lookbehind all vary between PCRE, JavaScript, Python and POSIX — a pattern is not portable without testing.

Common errors and gotchas

Assuming one flavour, since lookbehind, named groups and unicode classes vary by engine.
Using a greedy quantifier where a lazy one was needed, which swallows far too much.
Forgetting that the dot excludes newlines unless a flag says otherwise.
Writing a pattern with nested quantifiers, which can backtrack catastrophically.
Copying a pattern without its flags, which changes its meaning entirely.