Regex-Spickzettel

Regular expressions describe a pattern that text either matches or does not. The syntax below is the JavaScript flavour; PCRE, Python, Go and Java agree on almost all of it — the differences are called out where they bite.

/^\d{4}-\d{2}-\d{2}$/.test('2026-08-22'); // true
'a1b2'.replace(/\d/g, '#'); // 'a#b#'

🔡 Character Classes

␣ Whitespace

🎯 Character Sets

• A set is an or over single characters — [abc] matches one character, not the string abc.
• ^ right after the opening [ negates the set.
• Inside a set, most metacharacters lose their meaning: . is a literal period, + a literal plus.

🔒 Escaping

Outside a character set, these need a backslash to be taken literally:

| Escape | Character | Escape | Character | | ------ | -------------------------------------- | ------ | ------------------- | --------------- | | \. | Period | \( | Opening parenthesis | | \^ | Caret | \) | Closing parenthesis | | \$ | Dollar sign | \[ | Opening bracket | | \\ | | Pipe | \] | Closing bracket | | \\ | Backslash | \{ | Opening brace | | \/ | Forward slash (only in /…/ literals) | \} | Closing brace |

Inside a character set only \\ and \] always need escaping. A ^ needs it only immediately after [, and a - only between two other characters.

🔢 Quantifiers

'<b>bold</b>'.match(/<.+>/)[0]; // '<b>bold</b>'  — greedy
'<b>bold</b>'.match(/<.+?>/)[0]; // '<b>'          — lazy

📍 Anchors & Boundaries

A word boundary sits between a \w and a \W (or the edge of the string), so \bcat\b matches cat in the cat sat but not in concatenate.

🔀 Alternation & Lookaround

Lookaround is zero-width: it tests the surroundings without consuming them, so nothing it matches ends up in the result.

🎁 Groups & Backreferences

// named groups make replacements readable
'2026-08-22'.replace(/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/, '$<d>/$<m>/$<y>');
// '22/08/2026'

const { groups } = /(?<user>\w+)@(?<host>[\w.]+)/.exec('jane@example.com');
// groups.user === 'jane', groups.host === 'example.com'

🚩 Flags

🔁 Replacement Patterns

ℹ️ Other tools spell these differently: \1 in sed, \g<1> in Python, ${1} in Go.

🧪 Where the Groups Show Up (JavaScript)

'2026-08-22'.match(/\d+/g)              // ['2026', '08', '22'] — no groups with /g
[...'a1b2'.matchAll(/([a-z])(\d)/g)]    // every match, with its groups
/(\d+)/.exec('abc 42')                  // ['42', '42', index: 4, ...]
/\d/.test('abc')                        // false
'a1'.replace(/(\w)(\d)/, (m, a, b) => b + a)   // '1a'
'a, b;c'.split(/[,;]\s*/)               // ['a', 'b', 'c']

⚠️ Gotchas

• . does not match newlines unless you set the s flag — a common surprise on multi-line input.
• A /g regex is stateful. Reusing the same object across test() calls advances lastIndex and skips matches; build a fresh one, or reset lastIndex = 0.
• Nested quantifiers backtrack catastrophically. (a+)+$ against a long non-matching string can hang the process — avoid overlapping repetition, prefer possessive/atomic groups where the flavour has them.
• Escape user input before putting it in a pattern; in JS, RegExp.escape() where available, otherwise s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').
• Don’t parse HTML with regex. Use a parser; regex cannot handle nesting.
• Backslashes double up in strings: new RegExp('\\d+') is the same pattern as /\d+/.

📚 Resources

• MDN — regular expressions
• regex101 — build and explain patterns
• RegExplained
• Regular-Expressions.info