Regex Cheat Sheet for JavaScript Developers

Regular expressions are one of the most powerful — and most forgotten — tools in a developer's toolkit. This cheat sheet covers everything you need: syntax, flags, JavaScript-specific methods, named groups, lookaheads, and the most common ready-to-use patterns.

Creating a Regex in JavaScript

There are two ways to create a regular expression in JavaScript:

// Literal syntax — use this when the pattern is known at write time
const re = /pattern/flags;

// Constructor syntax — use this when the pattern is dynamic
const re = new RegExp('pattern', 'flags');
const re = new RegExp(userInput, 'i'); // ⚠ sanitize userInput first

// Examples
const emailRe = /^[\w.-]+@[\w.-]+\.[a-z]{2,}$/i;
const dynRe = new RegExp('^' + prefix + '\\d+$');

Anchors

Character Classes

Quantifiers

Greedy vs lazy: By default quantifiers are greedy — they match as much as possible. Add ? after any quantifier to make it lazy (match as little as possible).

const html = '<b>bold</b><i>italic</i>';

// Greedy — matches from first < to last >
html.match(/<.+>/)[0];   // '<b>bold</b><i>italic</i>'

// Lazy — matches the shortest possible
html.match(/<.+?>/)[0];  // '<b>'

Groups and Alternation

// Numbered capture groups
const date = '2026-04-09';
const m = date.match(/(\d{4})-(\d{2})-(\d{2})/);
// m[1] = '2026', m[2] = '04', m[3] = '09'

// Named capture groups (ES2018+)
const m2 = date.match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/);
// m2.groups.year = '2026', m2.groups.month = '04', m2.groups.day = '09'

// Non-capturing group — groups without creating a backreference
const re = /(?:https?|ftp):\/\//;  // matches http:// or https:// or ftp://

Lookahead and Lookbehind

Lookarounds match a position without consuming characters. The text inside the lookaround is not included in the match result.

Flags

JavaScript String and RegExp Methods

// ---- String methods that take a regex ----

// test: returns true/false
/^\d+$/.test('123');         // true
/^\d+$/.test('12a');         // false

// match: returns first match (without g) or all matches (with g)
'hello world'.match(/\w+/);  // ['hello', index: 0, ...]
'hello world'.match(/\w+/g); // ['hello', 'world']

// matchAll: returns iterator of all matches with groups (requires g flag)
const matches = [...'2026-04-09'.matchAll(/(\d{4})-(\d{2})-(\d{2})/g)];
matches[0][1]; // '2026'

// replace: replace first match (without g) or all (with g)
'foo bar foo'.replace(/foo/, 'baz');   // 'baz bar foo'
'foo bar foo'.replace(/foo/g, 'baz'); // 'baz bar baz'

// Replace with function — args: (match, group1, group2..., offset, string)
'hello world'.replace(/(\w+)/g, (match) => match.toUpperCase());
// 'HELLO WORLD'

// replaceAll: ES2021+, no g flag needed
'foo bar foo'.replaceAll('foo', 'baz'); // 'baz bar baz'
'foo bar foo'.replaceAll(/foo/g, 'baz'); // still needs g flag with regex

// search: returns index of first match or -1
'hello world'.search(/world/); // 6
'hello world'.search(/xyz/);   // -1

// split: split string using regex as delimiter
'one1two2three'.split(/\d/);  // ['one', 'two', 'three']

// ---- RegExp methods ----

// exec: returns match result or null, advances lastIndex when global
const re = /\d+/g;
const str = 'abc 123 def 456';
let m;
while ((m = re.exec(str)) !== null) {
  console.log(`Found ${m[0]} at index ${m.index}`);
}
// Found 123 at index 4
// Found 456 at index 12

Common Regex Patterns

Note on email validation: The regex above catches most invalid emails but the full email spec (RFC 5321) is far more complex. For production use, send a confirmation email rather than relying on regex alone.

Backreferences

You can refer to a previously captured group within the same regex using \1, \2, etc., or by name with \k<name>.

// Match duplicate words
/\b(\w+)\s+\1\b/.test('the the');  // true — \1 refers to group 1

// Named backreference
/(?<word>\w+)\s+\k<word>/.test('hello hello');  // true

// Match HTML open/close tag pairs
/<(\w+)>.*?<\/\1>/s.test('<b>text</b>');  // true
/<(\w+)>.*?<\/\1>/s.test('<b>text</i>');  // false

Special Characters That Need Escaping

These characters have special meaning in regex and must be escaped with \ to match them literally:

. * + ? ^ $ { } [ ] | ( ) \

// To match a literal dot:
/\./.test('3.14');  // true (matches the dot)
/./.test('3.14');   // true (matches any character — not what you want)

// Never pass unsanitized user input directly to RegExp constructor:
// const re = new RegExp(userInput);  ← dangerous if input contains *, +, |, etc.

// Use the escape-string-regexp package (npm install escape-string-regexp):
import escapeStringRegexp from 'escape-string-regexp';
const userInput = 'hello.world';
const re = new RegExp(escapeStringRegexp(userInput));  // safe

Want to test a regex pattern interactively? Open the Regex Tester →