Regex Cheat Sheet
Look up any JavaScript regex construct — syntax, meaning and a worked example whose result this page computes, with the tester right above the table.
Edit the pattern, flags or test string here. Every “Try it” button below loads that row's example into this tester.
Drop a text file on the test string pane — it is read on this device and never uploaded.
Native JavaScript replace semantics — the preview pane below updates as you type.
Press ? for shortcuts
All 73 constructs shown
Character classes
Character classes — syntax, meaning, example and computed result
| Syntax | Meaning | Example | Result |
|---|---|---|---|
. | Matches any single character except a line terminator. With the s flag it matches line terminators too; inside a character class it is an ordinary dot and needs no backslash. | a.c | /a.c/ "abc" → ✓ "abc" "a\nc" → ✗ no match |
\d | Matches one ASCII digit, 0 to 9. It never matches digits from other scripts, even with the u flag. | \d | /\d/ "a1" → ✓ "1" "abc" → ✗ no match |
\D | Matches one character that is not an ASCII digit. | \D | /\D/ "12a" → ✓ "a" "123" → ✗ no match |
\w | Matches one ASCII letter, digit or underscore — the same set as [A-Za-z0-9_]. Accented letters such as é are not word characters; use \p{L} with the u flag for those. | \w | /\w/ "_a" → ✓ "_" "!?" → ✗ no match |
\W | Matches one character outside [A-Za-z0-9_]. | \W | /\W/ "a!" → ✓ "!" "abc" → ✗ no match |
\s | Matches one whitespace character: space, tab, form feed, vertical tab, a line terminator or a Unicode space separator. | \s | /\s/ "a b" → ✓ " " "ab" → ✗ no match |
\S | Matches one character that is not whitespace. | \S | /\S/ " a" → ✓ "a" " " → ✗ no match |
[abc] | Matches any one of the characters listed between the brackets. | [abc] | /[abc]/ "cat" → ✓ "c" "dog" → ✗ no match |
[^abc] | Matches any one character that is not listed after the caret. It still has to consume a character, so it never matches at the end of the input. | [^abc] | /[^abc]/ "dog" → ✓ "d" "cab" → ✗ no match |
[a-z] | Matches one character whose code point falls between the two characters around the hyphen. | [a-z] | /[a-z]/ "Zebra" → ✓ "e" "ZEBRA" → ✗ no match |
[a-] | A hyphen first or last inside a class is a literal hyphen, not a range. | [a-] | /[a-]/ "-" → ✓ "-" "b" → ✗ no match |
[\]] | An escaped closing bracket inside a class matches a literal ]. Without the backslash the class would end at that bracket. | [\]] | /[\]]/ "]" → ✓ "]" "[" → ✗ no match |
[a^] | A caret anywhere but the first position inside a class is a literal caret. | [a^] | /[a^]/ "^" → ✓ "^" "b" → ✗ no match |
[\b] | Inside a character class, \b matches the backspace character U+0008. This is the one place where \b is not a word boundary. | [\b] | /[\b]/ "\b" → ✓ "\b" "b" → ✗ no match |
Anchors
Anchors — syntax, meaning, example and computed result
| Syntax | Meaning | Example | Result |
|---|---|---|---|
^ | Asserts the position at the start of the input. With the m flag it also asserts the start of every line. | ^cat | /^cat/ "cat nap" → ✓ "cat" "a cat" → ✗ no match |
$ | Asserts the position at the end of the input. With the m flag it also asserts the end of every line. | cat$ | /cat$/ "a cat" → ✓ "cat" "cat nap" → ✗ no match |
\b | Asserts a position where a word character meets a non-word character or the edge of the input. It matches a position, not a character, so it consumes nothing. | \bcat\b | /\bcat\b/ "cat nap" → ✓ "cat" "concat" → ✗ no match |
\B | Asserts a position that is not a word boundary: either both sides are word characters, or neither is. | \Bcat | /\Bcat/ "concat" → ✓ "cat" "cat nap" → ✗ no match |
Quantifiers
Quantifiers — syntax, meaning, example and computed result
| Syntax | Meaning | Example | Result |
|---|---|---|---|
* | Repeats the preceding item zero or more times, taking as many as it can. A quantifier applies to the single item before it, so ab* repeats b, not ab. | ab*c | /ab*c/ "ac" → ✓ "ac" "abbbc" → ✓ "abbbc" |
+ | Repeats the preceding item one or more times, taking as many as it can. | ab+c | /ab+c/ "abbc" → ✓ "abbc" "ac" → ✗ no match |
? | Makes the preceding item optional: zero or one occurrence. | colou?r | /colou?r/ "color" → ✓ "color" "colour" → ✓ "colour" |
{3} | Repeats the preceding item exactly that many times. | \d{3} | /\d{3}/
"12345" → ✓ "123"
"12" → ✗ no match |
{2,} | Repeats the preceding item at least that many times, taking as many as it can. | \d{2,} | /\d{2,}/
"1234" → ✓ "1234"
"1" → ✗ no match |
{2,5} | Repeats the preceding item between the two counts, preferring the longer run. The counts are a preference, not a boundary: without an anchor the match can start anywhere. | \d{2,5} | /\d{2,5}/
"1234567" → ✓ "12345"
"1" → ✗ no match |
*? | Repeats zero or more times, preferring the shortest run that still lets the pattern match. | <.*?> | /<.*?>/ "<a><b>" → ✓ "<a>" |
+? | Repeats one or more times, preferring the shortest run. | \d+? | /\d+?/ "1234" → ✓ "1" |
?? | Matches zero or one occurrence, preferring zero. | ab?? | /ab??/ "ab" → ✓ "a" |
{2,5}? | Repeats between the two counts, preferring the fewest. | \d{2,5}? | /\d{2,5}?/
"1234567" → ✓ "12" |
{ | A brace that does not open a valid quantifier is matched as a literal { character. The u and v flags reject it instead: under those flags a lone brace is a syntax error. | a{ | /a{/
"a{" → ✓ "a{"
"a" → ✗ no match |
Groups and references
Groups and references — syntax, meaning, example and computed result
| Syntax | Meaning | Example | Result |
|---|---|---|---|
(…) | Groups the enclosed pattern and captures what it matched for later reference. | (ab)+ | /(ab)+/ "abab" → ✓ "abab" "ba" → ✗ no match |
(?:…) | Groups the enclosed pattern without capturing it. | (?:ab)+ | /(?:ab)+/ "abab" → ✓ "abab" "ba" → ✗ no match |
(?<name>…)Added in ES2018 | Captures the enclosed pattern under a name, readable from the match's groups object. A name may be reused only by groups in different alternation branches (ES2025); otherwise it is a syntax error. | (?<year>\d{4}) | /(?<year>\d{4})/
"in 2026" → ✓ "2026"
"in 26" → ✗ no match |
\1 | Matches the same text an earlier capture group matched, counted from the left. | (\w)\1 | /(\w)\1/ "book" → ✓ "oo" "abc" → ✗ no match |
\k<name>Added in ES2018 | Matches the same text the named group matched. | (?<c>\w)\k<c> | /(?<c>\w)\k<c>/ "letter" → ✓ "tt" "abc" → ✗ no match |
| | Tries the left side, then the right — the lowest-precedence operator in a pattern. It splits everything around it unless a group encloses it. | cat|dog | /cat|dog/ "hotdog" → ✓ "dog" "bird" → ✗ no match |
Lookaround
Lookaround — syntax, meaning, example and computed result
| Syntax | Meaning | Example | Result |
|---|---|---|---|
(?=…) | Asserts that what follows matches, without consuming it. | \bcat(?= nap) | /\bcat(?= nap)/ "cat nap" → ✓ "cat" "cat food" → ✗ no match |
(?!…) | Asserts that what follows does not match, without consuming it. | \bcat(?! nap) | /\bcat(?! nap)/ "cat food" → ✓ "cat" "cat nap" → ✗ no match |
(?<=…)Added in ES2018 | Asserts that what precedes the current position matches. JavaScript lookbehind may be variable length, unlike PCRE's fixed-length rule. | (?<=€)\d+ | /(?<=€)\d+/ "€42" → ✓ "42" "$42" → ✗ no match |
(?<!…)Added in ES2018 | Asserts that what precedes the current position does not match. | (?<!€)\d+ | /(?<!€)\d+/ "$42" → ✓ "42" "€4" → ✗ no match |
Escapes
Escapes — syntax, meaning, example and computed result
| Syntax | Meaning | Example | Result |
|---|---|---|---|
\. | A backslash makes the next metacharacter literal — here, a dot that matches only a dot. | 3\.14 | /3\.14/ "3.14" → ✓ "3.14" "3x14" → ✗ no match |
\t | Matches the tab character U+0009. | \t | /\t/ "a\tb" → ✓ "\t" "a b" → ✗ no match |
\n | Matches the line feed character U+000A. | a\nb | /a\nb/ "a\nb" → ✓ "a\nb" "a b" → ✗ no match |
\r | Matches the carriage return character U+000D. | \r | /\r/ "a\r\n" → ✓ "\r" "a\n" → ✗ no match |
\f | Matches the form feed character U+000C. | \f | /\f/ "a\fb" → ✓ "\f" "a b" → ✗ no match |
\v | Matches the vertical tab character U+000B. As a flag letter, v means something else entirely: Unicode sets. | \v | /\v/ "a\u000bb" → ✓ "\u000b" "a b" → ✗ no match |
\0 | Matches the null character U+0000. It is the null character only when no digit follows it. | \0 | /\0/ "a\u0000b" → ✓ "\u0000" "a0b" → ✗ no match |
\cJ | Matches the control character for the given letter: \cJ is U+000A. | \cJ | /\cJ/ "a\nb" → ✓ "\n" "aJb" → ✗ no match |
\xA9 | Matches the character with that two-digit hexadecimal code. | \xA9 | /\xA9/ "© 2026" → ✓ "©" "(c) 2026" → ✗ no match |
\u00e9 | Matches the character with that four-digit hexadecimal code unit. Without the u flag this is one UTF-16 code unit, so a character above U+FFFF needs both halves of its surrogate pair. | caf\u00e9 | /caf\u00e9/ "café" → ✓ "café" "cafe" → ✗ no match |
Unicode properties and sets
Unicode properties and sets — syntax, meaning, example and computed result
| Syntax | Meaning | Example | Result |
|---|---|---|---|
\p{L}Needs the u flagAdded in ES2018 | Matches one character carrying that Unicode property — here, any letter in any script. | \p{L}+ | /\p{L}+/u
"Ωmega" → ✓ "Ωmega"
"123" → ✗ no match |
\P{L}Needs the u flagAdded in ES2018 | Matches one character that does not carry the named property. | \P{L} | /\P{L}/u
"a1" → ✓ "1"
"abc" → ✗ no match |
\p{Lu}Needs the u flagAdded in ES2018 | Matches one uppercase letter in any script. | \p{Lu} | /\p{Lu}/u
"aBc" → ✓ "B"
"abc" → ✗ no match |
\p{Script=Greek}Needs the u flagAdded in ES2018 | Matches one character belonging to the named script. | \p{Script=Greek}+ | /\p{Script=Greek}+/u
"λόγος" → ✓ "λόγος"
"logos" → ✗ no match |
\u{1F600}Needs the u flagAdded in ES2015 | Matches the character with that code point, including code points above U+FFFF. | \u{1F600} | /\u{1F600}/u
"a😀b" → ✓ "😀"
"a:)b" → ✗ no match |
\p{Alpha} | Without the u or v flag, \p is just the letter p, so this matches the literal text p{Alpha}. Adding u or v turns the same text into a property escape — and rejects unknown property names outright. | \p{Alpha} | /\p{Alpha}/
"p{Alpha}" → ✓ "p{Alpha}"
"abc" → ✗ no match |
[\p{L}--[aeiou]]Needs the v flagAdded in ES2024 | Matches characters in the left set that are not in the right set. | [\p{L}--[aeiou]] | /[\p{L}--[aeiou]]/v
"aeiou b" → ✓ "b"
"aeiou" → ✗ no match |
[\p{ASCII}&&\p{L}]Needs the v flagAdded in ES2024 | Matches characters that belong to both sets. | [\p{ASCII}&&\p{L}] | /[\p{ASCII}&&\p{L}]/v
"Ωa" → ✓ "a"
"Ω1" → ✗ no match |
\p{RGI_Emoji}Needs the v flagAdded in ES2024 | Matches a property of strings: a whole emoji sequence rather than a single code point. | \p{RGI_Emoji} | /\p{RGI_Emoji}/v
"👨👩👧" → ✓ "👨👩👧"
"abc" → ✗ no match |
Flags[2]
Flags — syntax, meaning, example and computed result
| Syntax | Meaning | Example | Result |
|---|---|---|---|
/…/g | Finds every match instead of stopping at the first one. A global regex object keeps lastIndex between calls, so reusing one across separate searches can skip matches. | \d | /\d/g "a1b2" → ✓ "1" "abc" → ✗ no match |
/…/i | Matches letters regardless of case. | cat | /cat/i "CAT" → ✓ "CAT" "dog" → ✗ no match |
/…/m | Re-points ^ and $ at the start and end of every line rather than of the whole input. | ^b | /^b/m "a\nb" → ✓ "b" "ab" → ✗ no match |
/…/sAdded in ES2018 | Lets . match line terminators as well. | a.c | /a.c/s "a\nc" → ✓ "a\nc" "ab\nc" → ✗ no match |
/…/uAdded in ES2015 | Reads pattern and input as code points, enables \p{…} and \u{…}, and rejects unknown escapes. | ^.$ | /^.$/u "😀" → ✓ "😀" "ab" → ✗ no match |
/…/yAdded in ES2015 | Anchors each attempt at lastIndex, so a match must begin exactly there. Combined with g, the sticky rule wins: matching still has to start at lastIndex. | \d | /\d/y "1a" → ✓ "1" "a1" → ✗ no match |
/…/vNeeds the v flagAdded in ES2024 | Extends u with set notation, properties of strings and case-insensitive set matching. u and v cannot be used together. | [\p{ASCII}&&\p{L}] | /[\p{ASCII}&&\p{L}]/v
"a" → ✓ "a"
"1" → ✗ no match |
Not in JavaScript[1]
Not in JavaScript — syntax, meaning, example and computed result
| Syntax | Meaning | Example | Result |
|---|---|---|---|
(?>…) | A group that throws away its backtracking positions once it has matched. PCRE, Java and Ruby have it; JavaScript does not. | (?>a) | /(?>a)/ Invalid regular expression: /(?>a)/: Invalid group |
*+ | A quantifier that never gives characters back while backtracking. Not part of JavaScript. | a*+ | /a*+/ Invalid regular expression: /a*+/: Nothing to repeat |
(?R) | Re-matches the whole pattern inside itself, for nested structures. Not part of JavaScript. | (?R) | /(?R)/ Invalid regular expression: /(?R)/: Invalid group |
(?i) | Switches flags on from inside the pattern. Not part of JavaScript: the letters go after the closing slash. | (?i)cat | /(?i)cat/ Invalid regular expression: /(?i)cat/: Invalid group |
(?(1)…) | Matches one branch or another depending on whether an earlier group took part. Not part of JavaScript. | (?(1)a|b) | /(?(1)a|b)/ Invalid regular expression: /(?(1)a|b)/: Invalid group |
(?P<name>…) | Python's spelling of a named group. JavaScript writes (?<name>…) instead. | (?P<n>a) | /(?P<n>a)/ Invalid regular expression: /(?P<n>a)/: Invalid group |
[[:alpha:]] | A POSIX bracket expression, as used by grep and sed. JavaScript has no POSIX classes: use \p{L} with the u flag. | [[:alpha:]] | /[[:alpha:]]/u Invalid regular expression: /[[:alpha:]]/u: Lone quantifier brackets |
\Z | An end-of-text anchor from Python and Go. JavaScript has $ only. | \Z | /\Z/u Invalid regular expression: /\Z/u: Invalid escape |
No construct matches that filter
The filter matches syntax tokens exactly as they are written, construct names, group names and single flag letters. Try a token like \b, a name like lookbehind, a group like quantifiers, or press Show all constructs.
Do it offline:$
How to use it
- Find the construct. Type the symbol — \B, {2,5}?, (?<name>…) — and its row surfaces; case matters, so \d and \D land on different rows. A word such as lookbehind works too, and so does a group name.
- Read across: symbol, meaning, the example pattern, then the inputs it was run against with the text each one matched.
- Press Try it to load that row's pattern, flags and first input into the tester above, then edit it against your own text — the same tester that runs on its own page, highlighting and copy-as-literal included.
- Share the row itself. Each construct carries a #c- anchor built from its id, so a link lands a colleague on the row rather than the page top.
Every JavaScript regular-expression construct in one place: the symbol, what it does, and a worked example whose result this page computed at build time rather than copying from a book. Type a symbol such as \b or (?<= to jump straight to its row, then try it in the tester at the top of this page.
How it works
No result column here is an author's memory. Each example pattern and its inputs are frozen data; at build time they run through the same matcher the tester uses, and the verdict that comes back is what gets printed. A row claiming to be valid JavaScript whose example will not compile stops the build, and rows for constructs the language lacks print the interpreter's own error text instead of a paraphrase.
Quantifiers go wrong in two ways. Scope: a quantifier repeats the single item to its left — one character, one class or one group — so ab+c repeats only the b, while (ab)+ repeats the pair. Appetite: by default it is greedy and takes the longest run that still lets the rest of the pattern succeed. A trailing ? makes it lazy and it takes the shortest, which is why <.*?> stops at the first closing angle bracket.
Four flag interactions change what an identical pattern means. u and v are rival Unicode modes and cannot both be set. g and y both keep a lastIndex cursor on the expression object, but y demands the match start exactly there while g may scan forward — reusing one expression without resetting lastIndex is a bug class of its own. s widens the dot to include line terminators. m instead re-points ^ and $ at every line break.
One note on provenance. These verdicts come from V8, the engine in Node, Chrome and Edge; a browser on that same V8 generation agrees, older ones can differ on the newest constructs. Safari runs JavaScriptCore and Firefox SpiderMonkey, and the edges differ: v reached them later, some Unicode property values trail a newer release, and error wording is not standardised, so the text on the unsupported rows is V8's phrasing, not a quotation from the specification. The grammar itself is ECMA-262 and does not vary.
Examples
\b/\bcat\b/
"cat nap" → ✓ "cat"
"concat" → ✗ no matchA boundary is a position, not a character, so the match text is cat with no padding. concat has no boundary before its final cat.
\B/\Bcat/
"concat" → ✓ "cat"
"cat nap" → ✗ no matchThe exact inverse, and why the filter is case-sensitive: the same two inputs swap verdicts, as they would for \D, \W, \S and \P.
{2,5}/\d{2,5}/
"1234567" → ✓ "12345"
"1" → ✗ no matchGreedy: given seven digits it takes five, the top of the range. One digit fails — a range is a minimum as much as a maximum.
{2,5}?/\d{2,5}?/
"1234567" → ✓ "12"The same range with ? appended, same input, two digits instead of five. Lazy still respects the floor; it stops the moment the rest of the pattern can succeed.
(?<=…)/(?<=€)\d+/
"€42" → ✓ "42"
"$42" → ✗ no matchLookbehind checks what precedes the match without consuming it: the euro sign is required yet stays out of the match text. JavaScript allows variable-length lookbehind, which several flavours refuse.
\p{Lu}/\p{Lu}/u
"aBc" → ✓ "B"
"abc" → ✗ no matchAny uppercase letter in Unicode, not just A-Z. It needs the u flag to be read as a property escape at all — the next row shows why.
\p{Alpha}/\p{Alpha}/
"p{Alpha}" → ✓ "p{Alpha}"
"abc" → ✗ no matchThe silent failure, printed rather than described: with no u flag the escape degrades to literal characters, matching the text p{Alpha} and missing every letter it was meant to catch.
(?>…)/(?>a)/
Invalid regular expression: /(?>a)/: Invalid groupAn atomic group is Perl and PCRE grammar, not JavaScript. Rather than assert that, the row prints the message the interpreter throws, captured at build time — as the possessive and recursion rows do.
Every example on this page is executed against the same engine that powers the tool, on every build.
Gotchas worth knowing
\b means backspace inside a character class
Outside brackets \b is a word boundary; inside them, [\b] is the backspace control character U+0008. They share a spelling and nothing else, so each gets its own row and anchor.
A hyphen or caret is literal in the right position
[a-] matches a or a hyphen, because a trailing hyphen cannot open a range; leading works the same. A caret negates only as the first character, so [a^] matches a or a caret. A closing bracket needs escaping as [\]] wherever it sits.
A brace is only a quantifier when it parses as one
a{ is valid and matches those two literal characters, since the brace opens nothing the grammar reads as a repetition count. That tolerance disappears under u and v, where an unescaped brace is a syntax error.
Zero-width matches and the empty result
Lookarounds, anchors and a quantifier with a zero floor can match without consuming anything. When one matches, the reported text is empty: a position satisfied it, not a character.
The v flag may be missing on the reader's engine
Set-notation rows need v, which arrived in ES2024. The page tests the engine it runs on for v before claiming anything about those rows, rather than asserting support your browser may lack.
There is no \Z in JavaScript
The Perl and Python end-of-text anchors are absent; $ with m off is the whole-string equivalent. \Z sits in the unsupported group beside recursion, conditionals, inline flag groups and the (?P<name>…) spelling.
Common errors
No construct matches that filter- Never a dead end. The block underneath repeats the token that could not be placed and names the shapes the box understands — an exact symbol, a construct id, a group name, a flag letter, or plain words — and Show all restores every row.
the u and v flags cannot be combined — pick one Unicode mode- What the embedded tester answers when both Unicode flags are ticked. v is a superset of u, so it replaces u rather than joining it. Pick v for set notation or string properties, u otherwise.
\p{…} is a Unicode property escape only when the u or v flag is set — without it the pattern matches the literal text "p{…}"- The quietest bug in the language: legal, compiles, runs, and means something else. It fires on the \p{Alpha} row above and in the tester whenever a property escape appears with neither Unicode flag set.
FAQ
How is this different from the pattern library on this site?
Different axis. The library hands you a finished expression for a known job — an email, a UUID. This table hands you the pieces such expressions are assembled from, one row per symbol.
Which flavour of regular expression does this cover?
JavaScript only, as defined by ECMA-262. Perl, PCRE, Python and POSIX constructs are still listed, grouped as unsupported and printed with the error an engine gives them — knowing a syntax is absent is worth a row.
Why does the filter treat \d and \D as different things?
Because the language does. Lowercase escapes name a set and uppercase escapes name its complement, so folding case would hand you the opposite construct. The symbol pass is matched exactly as typed; searching by word or group name is case-insensitive.
Are the results in the table checked against anything?
Twice. Every row is executed at build time and the printed verdict is whatever came back; the test suite then re-derives each line with a plain RegExp and compares character by character.
What is the difference between greedy and lazy repetition?
A greedy quantifier takes all it can and gives characters back only when the rest of the pattern fails; a lazy one, marked with a trailing question mark, takes as little as possible. Compare the two {2,5} rows above on identical input.
Can a pattern from this table hang my program?
A quantifier over a group that itself repeats can backtrack exponentially on input that nearly matches; that subject belongs to the tester page, which runs patterns off the main thread under a one-second cutoff.
Is there a link to a single construct?
Yes — every row carries an anchor built from its id, in the form #c- followed by that id. There are no per-construct pages and none are planned, so anchors are the durable address.
Keyboard shortcuts
- /
- Focus the filter
- ⌘/Ctrl + Enter
- Run / re-run
- ⌘/Ctrl + S
- Export matches (.txt)
- ⌘/Ctrl + C
- Copy the JS literal (with nothing selected)
- ⌘/Ctrl + Shift + C
- Copy the JS literal
- ? or ⌘/Ctrl + /
- Keyboard shortcuts