Regex Cheat Sheet

A complete JavaScript regular expression reference. All syntax elements with descriptions and examples — bookmark this page for quick lookups while writing regex patterns.

Open the Regex Tester

Character Classes

Character classes match a single character from a defined set.

Syntax	Description	Example / Match
.	Any character except newline (use s flag to include newlines)	`c.t`cat, cut, c1t
\d	Any digit — equivalent to [0-9]	`\d{3}`123, 456, 000
\D	Any non-digit character	`\D+`abc, hello, !!
\w	Word character — [a-zA-Z0-9_]	`\w+`hello, foo_bar, abc123
\W	Non-word character	`\W+`spaces, punctuation
\s	Any whitespace — space, tab, newline	`a\sb`a b, a\tb
\S	Any non-whitespace character	`\S+`any word or token
[abc]	Character set — matches a, b, or c	`[aeiou]`a, e, i, o, u
[^abc]	Negated set — matches anything except a, b, or c	`[^0-9]`any non-digit
[a-z]	Character range — matches any letter a through z	`[a-zA-Z]`any letter

Quantifiers

Quantifiers specify how many times the preceding element must occur. By default they are greedy (match as many characters as possible). Add ? to make them lazy.

Syntax	Description	Example / Match
*	0 or more (greedy)	`ab*c`ac, abc, abbc, abbbc
+	1 or more (greedy)	`\d+`1, 12, 123, 99999
?	0 or 1 — makes the preceding element optional	`colou?r`color, colour
{n}	Exactly n times	`\d{4}`2024, 0000, 9999
{n,}	n or more times	`\w{3,}`cat, hello, longer
{n,m}	Between n and m times (inclusive)	`\d{2,4}`12, 123, 1234
*?	0 or more (lazy — matches as few as possible)	`<.*?>`First tag only in <a><b>
+?	1 or more (lazy)	`\d+?`First digit only
??	0 or 1 (lazy)	`ab??c`ac preferred over abc

Anchors

Anchors match a position in the string rather than a character.

Syntax	Description	Example / Match
^	Start of string. With m flag: start of each line	`^Hello`"Hello world" but not "Say Hello"
$	End of string. With m flag: end of each line	`world$`"Hello world" but not "world peace"
\b	Word boundary — position between a word char and non-word char	`\bcat\b`"cat" but not "concatenate"
\B	Non-word boundary	`\Bcat\B`"concatenate" but not standalone "cat"

Groups & Alternation

Groups capture portions of the match for extraction or backreference. Use them to apply quantifiers to multi-character sequences.

Syntax	Description	Example / Match
(abc)	Capture group — captured in match[1], match[2], etc.	`(\d{4})-(\d{2})`2024-01 → groups: 2024, 01
(?:abc)	Non-capturing group — groups without capturing	`(?:https?://)`http:// or https:// (not captured)
(?<name>abc)	Named capture group — accessible as match.groups.name	`(?<year>\d{4})`match.groups.year = '2024'
\1, \2	Backreference to capture group 1, 2… (in pattern)	`(\w)\1`aa, bb, cc (doubled letters)
$1, $2	Backreference in replace string (use $& for full match)	`Replace (\w+) with [$1]`hello → [hello]
a\|b	Alternation — matches a or b	`cat\|dog`cat, dog

Lookahead & Lookbehind

Lookaround assertions match a position based on what precedes or follows, without consuming characters.

Syntax	Description	Example / Match
(?=abc)	Positive lookahead — matches if followed by abc	`\d+(?= dollars)`100 in '100 dollars'
(?!abc)	Negative lookahead — matches if NOT followed by abc	`\d+(?! dollars)`100 in '100 euros' but not '100 dollars'
(?<=abc)	Positive lookbehind — matches if preceded by abc	`(?<=\$)\d+`100 in '$100'
(?<!abc)	Negative lookbehind — matches if NOT preceded by abc	`(?<!\$)\d+`100 in '100px' but not '$100'

Flags

Flags modify how the regex engine interprets the pattern. In JavaScript, flags are passed as the second argument to new RegExp() or appended after the closing / delimiter.

Syntax	Description	Example / Match
g	Global — find all matches, not just the first	`/\d/g`All digits in the string
i	Case-insensitive — treat uppercase and lowercase as equal	`/hello/i`hello, Hello, HELLO
m	Multiline — ^ and $ match start/end of each line	`/^\w+/gm`First word of every line
s	DotAll — makes . match newlines too	`/a.b/s`a\nb (across newline)
u	Unicode — full Unicode support, enables \p{} escapes	`/\p{Letter}+/gu`Any Unicode letter sequence
y	Sticky — matches only at lastIndex position	`/\d+/y`Used for sequential parsing
d	Indices — includes start/end indices of each match group	`/(?<n>\d+)/d`match.indices.groups.n = [start, end]

Special Characters & Escaping

These characters have special meaning in regex. Prefix them with \ to match them literally.

Syntax	Description	Example / Match
\.	Literal dot (unescaped . matches any char)	`3\.14`3.14 (not 3X14)
\*	Literal asterisk	`1\2`12
\n	Newline	`line1\nline2`Matches across a newline
\t	Tab character	`col1\tcol2`Tab-separated values
\r	Carriage return	`\r\n`Windows-style line ending
\uXXXX	Unicode code point (4 hex digits)	`\u00E9`é (e with accent)

Ready to test a pattern? Open the live regex tester — real-time matching, group highlighting, and a patterns library.

Open Regex Tester