A bulk regex cheat sheet is a searchable reference for finding many regular-expression tokens quickly, checking their exact meaning, and copying JavaScript syntax without mixing in another dialect. The Regex Cheat Sheet provides 44 curated ECMAScript RegExp entries across six categories: characters, character classes, groups and references, quantifiers, assertions, and flags. Search by a token such as \d or a concept such as “lookbehind,” “Unicode,” “lazy,” or “named,” then use a category filter to narrow the results. Each result gives you the exact token, a concise meaning, and a JavaScript example. Select Copy on one row to place only that row’s exact token on the clipboard, without the example’s slash delimiters or flags. Search and filtering happen in the current browser tab, and queries, selected categories, copied tokens, and other input are not uploaded. The dialect boundary matters because PCRE, Python, .NET, Java, RE2, POSIX, shell globs, and editor modes can share familiar-looking symbols while differing in support or meaning. This tool is therefore a syntax reference, not a validator, security analyzer, compatibility database, or promise that a pattern is efficient.
What the 44-Entry JavaScript Sheet Covers
The reference is deliberately fixed to JavaScript RegExp as defined by ECMAScript. Its 44 selected entries are divided into six non-empty categories, and every row includes a category, exact token, concise meaning, and JavaScript example. Entries are checked against ECMAScript’s RegExp pattern grammar and cross-checked with MDN’s JavaScript regular-expression syntax cheat sheet.
| Category | Coverage | Useful searches |
|---|---|---|
| Characters | Dot, ASCII digit and word escapes, whitespace escapes, and Unicode property escapes | \d, \w, dot, whitespace |
| Character classes | Listed, negated, and ranged classes | range, negated class |
| Groups and references | Numbered and named captures, non-capturing groups, and numbered or named backreferences | named, backreference |
| Quantifiers | Zero-or-more, one-or-more, optional, exact, bounded, and lazy repetition | lazy, exact count, bounded count |
| Assertions | Anchors, boundaries, lookahead, and lookbehind | anchor, boundary, lookbehind |
| Flags | d, g, i, m, s, u, v, and y | Unicode, line terminator, lastIndex |
Search terms can find tokens, meanings, examples, or categories. A search for \d locates the exact digit token, while concept searches such as “lookbehind” or “line terminator” surface relevant meanings and examples. Search and category filters combine, and the displayed count reports the complete number of matches without a hidden result cap. If the combination returns nothing, the interface shows an explicit empty state.
Find and Copy a JavaScript RegExp Token
- Enter a token or concept in the search field. Use an exact symbol when you know it, such as \d, or a descriptive term when you are looking for behavior such as “Unicode,” “lazy,” “named,” or “lookbehind.”
- Choose a category to narrow the JavaScript-specific entries. Select the relevant category when the first result set is broader than needed. The category and text query work together.
- Review the matching row. Check the exact token, concise meaning, and runnable-style JavaScript example. Examples are regular-expression literals, so slash delimiters and relevant flags remain visible.
- Select Copy on the row you need. The clipboard receives only the exact token from the Token column—not its category, explanation, example, slash delimiters, or example flags.
Clipboard access can still be denied by the browser. In that case, the tool reports a recoverable error instead of claiming that copying succeeded. Changing the search or category also invalidates an older clipboard job and clears its status, preventing delayed feedback from being associated with a different filtered view. Complete the copy before changing filters when you need an unambiguous result.
Search by Symbol, Concept, or Category
A bulk lookup works best when you can switch between precise symbols and plain-language concepts. Use the following starting points to reduce the number of rows you need to inspect.
| Lookup goal | Start with | Category to consider | Check before copying |
|---|---|---|---|
| Find a digit escape | \d | Characters | Its JavaScript meaning is ASCII digits, not every Unicode decimal digit |
| Find lookbehind | lookbehind | Assertions | Positive and negative forms differ, and neither consumes preceding text |
| Find Unicode properties | Unicode or \p{Letter} | Characters or Flags | The property escape requires u or v |
| Find lazy repetition | lazy | Quantifiers | The default is greedy; adding ? after a quantifier makes it lazy |
| Find named grouping | named | Groups and references | A named capture and a named backreference perform different jobs |
| Check dot behavior | line terminator | Characters or Flags | The s flag changes whether dot can match line terminators |
For a bulk collection session, work through the categories in a deliberate order and copy only the components the pattern needs. Search by exact syntax when inserting a character escape or assertion; search by meaning when deciding between captures, backreferences, or quantifiers. Review the example for required context, but do not mistake that example for clipboard output. A copied Unicode property escape still needs its required flag, and a copied token is not automatically a complete pattern.
JavaScript Details That Generic Sheets Can Blur
Characters, classes, and Unicode
In JavaScript, \d matches the ASCII digits 0 through 9; it is not a shortcut for every Unicode decimal digit. The \w entry primarily covers ASCII letters, ASCII digits, and underscore, with a documented Unicode-aware case-folding nuance when i and u are combined. To match Unicode properties such as Letter, use \p{Letter} with the u or v flag. Its complement is \P{Letter}. A property escape does not work without an appropriate Unicode-aware mode.
Character classes distinguish [abc], which lists allowed characters; [^abc], which negates the listed set; and [a-z], which defines an inclusive range. Escape rows cover \xHH for two-digit hexadecimal, \uHHHH for a four-digit UTF-16 code unit, and \u{...} for a braced Unicode code point. The braced form requires u or v.
Groups, repetition, assertions, and flags
Grouping syntax is not interchangeable. A non-capturing group such as (?:...) controls grouping without creating another capture slot, while a numbered group such as (...) does capture. The reference distinguishes those forms from named captures. A numbered backreference such as \1 and a named backreference such as \k<name> match text captured earlier; they are not substitutes for the group that created the capture. Alternation is shown as x|y.
Quantifiers are greedy by default. Adding ? after a quantifier makes that quantifier lazy, as in +?, but it does not make the repeated expression optional in the way a standalone optional quantifier does. JavaScript lookbehind uses (?<=...) for a positive assertion and (?<!...) for a negative assertion. Both examine text before the current position without consuming that preceding text.
The flag section includes d, g, i, m, s, u, v, and y. The s flag lets dot match line terminators, while m changes how ^ and $ handle line boundaries. The g flag enables global matching and affects lastIndex in stateful operations; y requires a match at lastIndex; and d exposes match indices. The newer v flag provides UnicodeSets behavior, including class-set operations and properties of strings, but JavaScript does not allow u and v on the same RegExp.
Turn Copied Tokens Into a Testable Pattern
Because Copy is component-level, delimiters, flags, and pattern structure remain your responsibility. Use each copied token only where it fits the expression you are building.
- Work category by category and collect only the characters, classes, groups, quantifiers, assertions, and flags required for the current pattern.
- Insert each copied token into an existing JavaScript pattern where its role is clear; a non-capturing group should not be used when you need a capture.
- Add required context separately. For example, \p{Letter} still needs u or v, and those flags cannot be combined.
- Use the row example to understand delimiters and flags, but do not expect them to appear in the clipboard result.
- Run the completed expression against representative inputs in the browser, embedded runtime, or Node.js version that will execute it.
When behavior matters, the Regex Tester is the related tool to consult. The MDN RegExp reference provides additional JavaScript-specific API and behavior details beyond a token lookup.
Know What the Reference Cannot Establish
The cheat sheet is a quick syntax reference, not a complete-pattern validator, security analyzer, compatibility database, or guarantee that a pattern will be efficient. A token can be copied exactly and still be unsuitable for the intended input, so test real patterns with representative data. Avoid uncontrolled backtracking on untrusted text. When code will run in a particular browser, embedded runtime, or older Node.js version, verify that environment’s feature support as well. Copying confirms which token was transferred; it does not confirm the assembled pattern’s correctness, safety, or runtime compatibility.
Related reading: How to Separate Excel Sheets Into Different Workbooks.