Regex Cheat Sheet: Tokens, Examples and Explanations

Regex dictionary: anchors and boundaries

Anchors do not match characters; they match positions. The most common regex bug is expecting ^ and $ to mean "start and end of the whole string" — in JavaScript they only do that without the m flag. With the multiline flag, they match at every line break instead, which is exactly what you want when scanning a log file line by line.

Python and PCRE also support \A (absolute string start) and \Z (absolute end); JavaScript does not — use ^ and $ without the m flag instead.

Regex dictionary: character classes

Character classes match one character out of a set. The shorthand classes (\d, \w, \s) are Unicode-aware in modern JavaScript only if you add the u flag; without it they are effectively ASCII. For digits with signs or decimals, combine classes rather than hoping one shorthand covers it.

Regex dictionary: quantifiers (and why lazy matters)

Quantifiers repeat the previous token. The critical detail is greediness: a greedy quantifier grabs as much as it can, then walks back; a lazy quantifier (extra ?) takes as little as it can. When a pattern like <.+> swallows an entire HTML fragment instead of one tag, the fix is the lazy form <.+?>.

Lazy versions (*?, +?, ??) share one idea: prefer the shortest match. <.+?> matches the single tag <b> inside "<b>hi</b>", where the greedy <.+> would swallow the whole string.

Regex new line: how to match line breaks correctly

The token \n matches a line feed, but real files usually end lines with a carriage return AND a line feed (\r\n on Windows, \n on Linux). The pattern \r?\n accepts both, which is why it is the safest way to split or match a new line in text copied from any operating system.

Matching "any character including the new line" is a different problem: the dot stops at \n by default. Two reliable fixes exist, and knowing both saves an hour of debugging.

• /\r?\n/ — match or split a new line, Windows and Unix safe
• /[\s\S]/ — "any character at all" in every regex flavor, no flags needed
• /./s — same thing in JavaScript only, with the dotAll (s) flag

"line1\r\nline2\nline3"
  .split(/\r?\n/);              // ["line1", "line2", "line3"]

"a\nb".match(/^a.b$/);          // null  (dot stops at \n)
"a\nb".match(/^a.b$/s);         // match (s = dotAll flag)
"a\nb".match(/a[\s\S]b/);       // match ([\s\S] = any char, any flavor)

Regex start of line: ^ with and without the multiline flag

This is the anchor question we see most. Without the m flag, ^ anchors to the very start of the string, so an ERROR at the top of a log matches but the same word mid-file does not. Add the m flag and ^ becomes "start of any line" — the pattern suddenly finds every error line, which is what people usually mean by a regex start-of-line match.

const log = "INFO boot\nERROR disk\nINFO ready";

log.match(/^ERROR/);        // null        (^ = string start)
log.match(/^ERROR/m);       // match       (m = every line start)
log.match(/^\w+$/gm);       // 3 matches   (each line, whole line)

Regex replace: capture groups and backreferences

A regex replace is where patterns earn their keep. Anything inside parentheses is a capture group; in the replacement string, $1, $2 … refer to the groups in order, and $& inserts the whole match. Named groups (?<year>\d{4}) make longer replacements readable — reference them as $<year> in JavaScript.

• $1, $2 — first, second capture group in the replacement
• $& — the entire matched text
• $` and $' — text before and after the match
• $<name> — a named group from (?<name>…)

"2026-10-23".replace(/(\d{4})-(\d{2})-(\d{2})/, "$3/$2/$1");
// "23/10/2026"

"Ada Lovelace".replace(/(?<first>\w+) (?<last>\w+)/, "$<last>, $<first>");
// "Lovelace, Ada"

Regex lookaround: match next to something without consuming it

Lookaheads and lookbehinds assert what must be next to the match without including it in the result. The classic use is password rules: require a digit somewhere in the string without matching the digit itself. Lookbehind arrived in JavaScript with ES2018 and is safe in every current browser.

/(?=.*\d).{8,}/.test("abc12345");        // true (has a digit, 8+ chars)
"price: $42".match(/(?<=\$)\d+/);          // "42"  (the $ is not included)

// negative lookahead: words NOT followed by a comma
"a, b c".match(/\w+\b(?!,)/g);             // ["b", "c"]

Six ready-to-use patterns (copy, paste, test)

These are the patterns behind half of all quick data-extraction jobs. Each one is deliberately strict about boundaries so it does not match fragments inside longer strings, and each is safe to paste straight into the tester with sample text.

The IPv4 pattern matches structure, not ranges: 999.999.999.999 passes. For validation (as opposed to extraction), add range checks in code.

How to test any pattern from this cheat sheet live

Reading a regex only gets you halfway; watching it match (or fail) on real text is what builds intuition. Open the regex tester, paste any pattern from this page with the sample flags, and you get live match highlighting, capture-group breakdowns and a replace preview as you type.

The tester runs the same ECMAScript engine as this cheat sheet describes, so flags, named groups and lookbehind behave exactly as documented here. Nothing is uploaded — the matching happens in your browser tab, which makes it safe for logs with sensitive lines in them.

Questions this guide answers

• regex cheat sheet
• regex new line
• regex dictionary
• regex start of line
• regular expression replace
• regex lookaround
• online regex checker
• regex generator