Writing Regex That Doesn't Make You Hate Yourself

Regex has a reputation. Part of that reputation is deserved — a complex pattern written without care is nearly unreadable. But most of what makes regex hard is not the patterns themselves; it's writing them without feedback, and not understanding the handful of meta-characters that govern how matching works.

This guide covers the building blocks you actually need, common patterns you'll write more than once, and how to debug when a pattern isn't doing what you expect.

The meta-characters you need to know

. (dot) — Matches any single character except a newline (by default). Often misused when the intent is to match a literal period. To match a literal dot, escape it: \.

* — Matches zero or more of the preceding element. a* matches empty string, a, aa, aaa…

+ — Matches one or more. a+ requires at least one a.

? — Matches zero or one. Makes the preceding element optional. Also used to make quantifiers lazy (non-greedy).

{n,m} — Matches between n and m times. \d{2,4} matches 2 to 4 digits.

^ — Anchors to the start of the string (or line in multiline mode). ^hello only matches if the string starts with "hello."

$ — Anchors to the end of the string. world$ only matches if the string ends with "world."

[] — Character class. [aeiou] matches any single vowel. [a-z] matches any lowercase letter. [^a-z] (with caret inside) matches anything that is NOT a lowercase letter.

() — Capturing group. Groups part of a pattern and captures the matched text. (\d{4})-(\d{2}) captures year and month separately.

| — Alternation. cat|dog matches either "cat" or "dog."

Shorthand character classes

• \d — Digit. Equivalent to [0-9].
• \w — Word character. [a-zA-Z0-9_].
• \s — Whitespace (space, tab, newline, carriage return).
• \D, \W, \S — Uppercase versions match the inverse (non-digit, non-word, non-whitespace).
• \b — Word boundary. Zero-width assertion that matches the position between a word character and a non-word character. \bcat\b matches "cat" but not "category" or "tomcat."

Greedy vs lazy quantifiers

By default, quantifiers are greedy — they match as much as possible. .* on the string abc123def will match the entire string. This is usually what you want, but sometimes you need the shortest possible match.

Adding ? after a quantifier makes it lazy: .*? matches as little as possible.

Consider matching content between HTML tags: <b>bold</b> and <b>more bold</b>

• Greedy: <b>.*</b> matches the entire string from first <b> to last </b>
• Lazy: <b>.*?</b> matches each bold section separately

Flags that change matching behavior

i (case insensitive) — Makes the pattern match regardless of case. /hello/i matches "Hello", "HELLO", "hElLo."

g (global) — Find all matches, not just the first. Without this flag, most regex implementations stop at the first match.

m (multiline) — Changes the behavior of ^ and $. Without this flag, they anchor to the start and end of the entire string. With it, they anchor to the start and end of each line.

s (dotAll) — Makes . match newlines too. Without this flag, a pattern with .* won't cross line boundaries.

Patterns you'll write repeatedly

Email address (pragmatic)

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

This is not RFC 5322 compliant (the actual spec for valid email syntax is extremely complex), but it catches obvious invalid inputs without false positives on valid addresses.

IPv4 address

/^(\d{1,3}\.){3}\d{1,3}$/

This matches the format but doesn't validate that each octet is 0–255. For full validation, you need to check the captured groups. For more on what those octets actually mean, see What Your IP Address Actually Reveals.

Extracting dates from logs (YYYY-MM-DD)

/\b(\d{4})-(\d{2})-(\d{2})\b/g

Matching a file extension

/\.(jpg|jpeg|png|gif|webp)$/i

Removing leading/trailing whitespace

/^\s+|\s+$/g

How to debug a regex that isn't matching

The most effective approach: break the pattern into smaller pieces and test each piece independently before combining them. Instead of debugging ^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z$ all at once, verify that \d{4} matches your four-digit year, then build up from there.

Second: check your flags. A pattern failing on "Hello World" with case-sensitive matching might work fine with the i flag. A pattern that seems to match one occurrence but misses others might need g.

Third: watch for common escaping mistakes. A literal dot is \., not .. A literal backslash is \\. Failing to escape these is the source of many mysterious non-matches and false positives.

The Regex Tester on ToolsKit highlights all matches in real time as you type the pattern — it's much faster for iterative debugging than writing test code.