⚡ Quick Reference
The 10 regex patterns that solve 90% of your problems, ready to copy-paste.
^[\w\.-]+@[\w\.-]+\.\w{2,}$
// URL
^https?:\/\/[\w.-]+\.[a-z]{2,}[\/\w .-]*$
// PHONE (US/Canada)
^\+?1?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$
// DATE (YYYY-MM-DD)
^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$
// PASSWORD (8+ chars, 1 upper, 1 lower, 1 digit)
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$
// IP ADDRESS (IPv4)
^(\d{1,3}\.){3}\d{1,3}$
// HTML TAG
<[a-z][\w]*[^>]*>.*?<\/[a-z][\w]*>
// EXTRACT NUMBERS
\d+(\.\d+)?
// MATCH WORDS (no numbers)
\b[A-Za-z]+\b
// REMOVE EXTRA SPACES
\s{2,}
Stop Slapping Your Keyboard Like a Monkey
You've been there. Staring at a string, knowing exactly what pattern you need to match, but your regex looks like someone fell asleep on the keyboard. You copy-paste from Stack Overflow, tweak a character, pray to the regex gods, and somehow it works (or spectacularly fails).
Regular expressions aren't magic—they're a martial art. And right now, you're the white belt trying to punch through a brick wall with your face. Let's fix that.
📋 TL;DR
- Anchors (^ $) are your boundaries—use them or get unexpected matches
- Greedy vs Lazy (* vs *?) determines how much your pattern eats
- Debugging flowchart below solves 95% of "why isn't this working?" moments
The Dojo: Essential Regex Concepts
Anchors & Boundaries (Your Starting Stance)
Anchors don't match characters—they match positions. Forget them, and your regex becomes a hungry hippo eating everything in sight.
/cat/
// RIGHT: Matches only strings that are exactly "cat"
/^cat$/
// Word boundary: Matches "cat" as a whole word
/\bcat\b/
Quantifiers: How Much Do You Want?
Quantifiers tell your pattern how many times to repeat. The greedy/lazy distinction is where most developers faceplant.
| Quantifier | Meaning | Greedy | Lazy |
|---|---|---|---|
| * | 0 or more | .* (eats everything) | .*? (minimal match) |
| + | 1 or more | .+ | .+? |
| {n,m} | Between n and m | .{3,5} | .{3,5}? |
Real example: Matching HTML tags. Greedy <.*> on "<div>hello</div>" matches the ENTIRE string. Lazy <.*?> matches just "<div>".
Groups & Captures (Your Grappling Holds)
Parentheses create groups. Some capture (remember what they matched), some don't. Use non-capturing groups (?:...) when you don't need the memory overhead.
Debugging Flowchart: "Why Isn't My Regex Working?"
Follow this when your pattern is misbehaving:
- Is it matching too much? → Add anchors ^ and $, or use lazy quantifiers *?
- Is it matching too little? → Check your character classes [a-z] vs \w, add case-insensitive flag /i
- Is it matching nothing? → Escape special characters . * + ? { } [ ] ( ) ^ $ | \ with backslash
- Are groups not capturing? → You're using (?:...) instead of (...)
- Still broken? → Use regex101.com or debuggex.com to visualize your pattern
Lookarounds: The Ninja Moves
Lookaheads and lookbehinds let you match patterns based on what comes before or after, without including it in the match. Powerful but confusing.
Practical use: Password validation requiring at least one digit, but not matching the digit itself.
Pro Tips From the Regex Masters
🎯 Black Belt Wisdom
1. Test Incrementally
Don't write the entire pattern at once. Start with a simple match, then add complexity. Regex testers are your dojo.
2. Comment Your Patterns
In languages that support it (Python, JavaScript x flag):
/^\d{3}-\d{2}-\d{4}$/x # US SSN format
3. Know When NOT to Use Regex
Parsing HTML/XML? Use a proper parser. Complex nested structures? Regex will make you cry.
4. Escape First, Ask Questions Later
When in doubt, backslash it out. \. matches a literal period, . matches any character.
5. Performance Matters
Avoid catastrophic backtracking: (a+)+b on "aaaaaaaaaz" will melt your CPU. Use atomic groups or possessive quantifiers where supported.
The Path to Mastery
Regex isn't about memorizing every metacharacter—it's about understanding the patterns. Start with the 10 patterns in the quick reference. Use the debugging flowchart when stuck. Practice on regex crosswords or regex golf challenges.
Remember: A black belt regex master isn't someone who writes complex patterns. It's someone who writes simple patterns that work reliably. Now go forth and match with intention, not desperation.
Next step: Bookmark regex101.com. When you hit a wall, visualize your pattern there before throwing your keyboard.
(Your coworkers will thank you for not committing regex crimes)
Quick Summary
- What: Developers waste hours trying to remember regex syntax, testing patterns that don't work, and debugging why /^.*$/ doesn't match what they think it should
💬 Discussion
Add a Comment