Regex Cheatsheet for Beginners (With Copy-Paste Examples)

Regular expressions look cryptic at first, but a small set of building blocks covers most real-world tasks: validating input, searching logs, and doing bulk find-and-replace. Learn these pieces and you can read and write most patterns you'll meet.

The basic building blocks

• . matches any single character except a newline.
• \d matches a digit, \w a word character (letters, digits, underscore), and \s whitespace. The capitals \D, \W, and \S mean the opposite.
• [abc] matches any one of a, b, or c. [a-z] is a range, and [^abc] matches anything except those.
• ^ and $ match the start and end of the string (or of each line with the m flag).
• \b matches a word boundary, which is handy for whole-word matches.
• Use a backslash to match a special character literally: \. matches a period, \( a parenthesis.

Quantifiers: how many times

• * means zero or more, + means one or more, and ? means zero or one.
• {3} means exactly 3, {2,5} means between 2 and 5, and {2,} means 2 or more.
• Quantifiers are greedy by default and grab as much as they can. Add a ? after one (like .*?) to make it lazy so it matches as little as possible.

<.+>     // greedy: on "<b>hi</b>" matches the whole string
<.+?>    // lazy:   matches "<b>" first

Groups, alternation, and backreferences

(cat|dog)s?                      // cat, cats, dog, dogs
(\d{4})-(\d{2})-(\d{2})         // capture year, month, day
(?<year>\d{4})-(?<month>\d{2})   // named groups
(?:abc)+                         // group without capturing
(\w)\1                           // a repeated character, like "ll" in "hello"

Lookaheads and lookbehinds

Lookarounds check what surrounds a position without including it in the match.

\d+(?= dollars)      // digits followed by " dollars"
\d+(?! dollars)      // digits NOT followed by " dollars"
(?<=\$)\d+           // digits preceded by "$"
(?<!\$)\b\d+          // digits NOT preceded by "$"

Flags

• g finds all matches instead of stopping at the first.
• i makes the match case-insensitive.
• m makes ^ and $ match at line boundaries.
• s lets . match newlines as well.

Practical patterns you can reuse

• ISO date (format only): ^\d{4}-\d{2}-\d{2}$
• Hex color: ^#(?:[0-9a-fA-F]{3}){1,2}$
• Simple email shape: ^[^\s@]+@[^\s@]+\.[^\s@]+$
• Trim extra spaces: \s{2,} replaced with a single space
• Slug: ^[a-z0-9]+(?:-[a-z0-9]+)*$

Common mistakes

• Forgetting to escape special characters like . and ?, which then match far more than intended.
• Using greedy .* and swallowing more text than you meant to.
• Nested quantifiers such as (a+)+ that can cause catastrophic backtracking on certain inputs and freeze your program.
• Assuming every engine behaves the same; lookbehind and named-group syntax differ between JavaScript, Python, and PCRE.

The fastest way to learn is to test against sample text and watch each match and group light up. Build the pattern one piece at a time.