There's a famous joke in programming circles: "Some people, when confronted with a problem, think 'I know, I'll use regular expressions.' Now they have two problems." It's funny because there's truth to it. Regex can be cryptic, frustrating, and maddeningly difficult to debug. A single character can change everything. And yet, once you understand the basics, regex becomes one of the most powerful tools in your toolkit. Let me show you how to get started without losing your mind. ## What Actually Is Regex? A regular expression (regex) is a pattern that describes a set of strings. It's a way to say "find me text that looks like this" without knowing the exact text you're looking for. For example, the regex pattern `\d{3}-\d{4}` matches any string that looks like a phone number: three digits, a hyphen, four digits. It would match "555-1234", "123-4567", "999-0000" — any text that fits that pattern. Regex is used for: - **Validation:** Does this string look like an email address? - **Search:** Find all URLs in this document - **Replace:** Change all phone numbers to format (XXX) XXX-XXXX - **Extraction:** Pull all the prices out of this webpage Every programming language supports regex. It's one of those skills that transfers everywhere. ## Your First Pattern Let's start simple. The most basic regex is just literal text: ``` Pattern: hello Text: Say hello to the world Match: "hello" ``` The pattern `hello` matches the literal text "hello". Nothing fancy yet. Try it in our [Regex Tester](/tools/regex-tester): enter the pattern `hello` and the text "Say hello to the world". You'll see "hello" highlighted. ## Character Classes: Matching Sets of Characters What if you want to match any digit? Or any letter? That's where character classes come in. **Square brackets** define a set of characters to match: ``` Pattern: [aeiou] Matches: any single vowel ``` This matches exactly one character that's either a, e, i, o, or u. You can also use **ranges**: ``` Pattern: [a-z] Matches: any lowercase letter Pattern: [A-Z] Matches: any uppercase letter Pattern: [0-9] Matches: any digit Pattern: [a-zA-Z0-9] Matches: any letter or digit ``` These are so common that regex has shortcuts: ``` \d = [0-9] any digit \w = [a-zA-Z0-9_] any "word" character \s = [ \t\n\r] any whitespace . = anything any character (except newline) ``` The uppercase versions are the opposite: ``` \D = [^0-9] NOT a digit \W = [^a-zA-Z0-9_] NOT a word character \S = [^\s] NOT whitespace ``` ## Quantifiers: How Many? So far, each pattern element matches exactly one character. Quantifiers let you match multiple characters: ``` * zero or more + one or more ? zero or one (optional) {3} exactly 3 {2,5} between 2 and 5 {3,} 3 or more ``` Let's build something useful. A US phone number like 555-123-4567: ``` Pattern: \d{3}-\d{3}-\d{4} Matches: "555-123-4567" ``` Breaking it down: - `\d{3}` — exactly 3 digits - `-` — a literal hyphen - `\d{3}` — exactly 3 more digits - `-` — another hyphen - `\d{4}` — exactly 4 digits Now let's handle optional elements. What if the phone number might or might not have parentheses around the area code? ``` Pattern: $?\d{3}$?[-.\s]?\d{3}[-.\s]?\d{4} ``` This matches: - `555-123-4567` - `(555) 123-4567` - `555.123.4567` - `555 123 4567` The `?` after `$?` and `$?` makes the parentheses optional. The `[-.\s]?` matches an optional separator (hyphen, period, or space). ## Anchors: Position Matters Sometimes you need to match text at a specific position: ``` ^ start of string (or line) $ end of string (or line) \b word boundary ``` Without anchors: ``` Pattern: test Text: "testing 123" Matches: "test" (inside "testing") ``` With anchors: ``` Pattern: ^test Text: "testing 123" Matches: "test" (at the start) Pattern: test$ Text: "this is a test" Matches: "test" (at the end) Pattern: \btest\b Text: "testing a test today" Matches: "test" (only the standalone word, not inside "testing") ``` ## Groups and Capturing Parentheses serve two purposes in regex: grouping and capturing. **Grouping** lets you apply quantifiers to multiple characters: ``` Pattern: (ha)+ Matches: "ha", "haha", "hahaha", etc. ``` **Capturing** lets you extract parts of the match: ``` Pattern: (\d{3})-(\d{4}) Text: "Call 555-1234" Full match: "555-1234" Group 1: "555" Group 2: "1234" ``` This is incredibly useful for parsing structured data. Want to extract all the domains from a list of URLs? Use capturing groups. ## Alternation: This OR That The pipe character `|` means "or": ``` Pattern: cat|dog Matches: "cat" or "dog" Pattern: (cats?|dogs?) Matches: "cat", "cats", "dog", or "dogs" ``` ## Real-World Examples Let's look at some patterns you'll actually use. ### Email Validation (Simple) ``` Pattern: ^\S+@\S+\.\S+$ ``` This matches strings that: - `^` — Start of string - `\S+` — One or more non-whitespace characters - `@` — Literal @ symbol - `\S+` — One or more non-whitespace characters - `\.` — Literal period (escaped with \) - `\S+` — One or more non-whitespace characters - `$` — End of string This isn't RFC-compliant email validation (that's absurdly complex), but it catches the obvious mistakes. ### URL Detection ``` Pattern: https?://[^\s]+ ``` - `https?` — "http" with an optional "s" - `://` — Literal "://" - `[^\s]+` — One or more non-whitespace characters ### Extracting Hashtags ``` Pattern: #\w+ ``` - `#` — Literal hash - `\w+` — One or more word characters This matches "#coding", "#100DaysOfCode", etc. ### Matching Dates ``` Pattern: \d{1,2}/\d{1,2}/\d{2,4} ``` Matches dates like "1/1/24", "12/31/2024", "3/15/99". ### Validating Hex Colors ``` Pattern: ^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$ ``` Matches "#FFF" or "#FFFFFF" format hex colors. ## Common Mistakes and Gotchas ### Forgetting to Escape Special Characters These characters have special meaning in regex: `. * + ? ^ $ { } [ ] \ | ( )` If you want to match a literal period, you need to escape it: `\.` ``` Pattern: example.com (WRONG - matches "exampleXcom") Pattern: example\.com (RIGHT - matches "example.com") ``` ### Greedy vs Lazy Matching By default, quantifiers are "greedy": they match as much as possible: ``` Pattern: <.*> Text: "bold" Matches: "bold" (the entire string!) ``` The `.*` gobbles up everything between the first `<` and the LAST `>`. If you want the shortest match, add `?` to make it "lazy": ``` Pattern: <.*?> Text: "bold" Matches: "" and "" (separately) ``` ### Forgetting Anchors in Validation ``` Pattern: \d{5} Text: "My zip is 123456789" Matches: "12345" (but also matches in longer strings!) ``` If you're validating that a string IS a 5-digit zip code: ``` Pattern: ^\d{5}$ ``` Now it only matches if the ENTIRE string is exactly 5 digits. ## Practice, Practice, Practice Regex is a skill that improves with practice. Use our [Regex Tester](/tools/regex-tester) to experiment: - Write a pattern - See matches highlighted in real-time - Test against multiple strings - Debug why something isn't matching Start with simple patterns and build up complexity. When you're stuck, break the problem down: what are you trying to match, exactly? ## Quick Reference **Character Classes:** ``` . any character \d digit [0-9] \w word char [a-zA-Z0-9_] \s whitespace [abc] a, b, or c [^abc] NOT a, b, or c ``` **Quantifiers:** ``` * 0 or more + 1 or more ? 0 or 1 {n} exactly n {n,m} between n and m ``` **Anchors:** ``` ^ start of string $ end of string \b word boundary ``` **Groups:** ``` (...) capturing group (?:...) non-capturing group | alternation (or) ``` ## Beyond the Basics This guide covers the fundamentals, but regex goes much deeper. Once you're comfortable with these concepts, you can explore: - Lookahead and lookbehind assertions - Backreferences - Named capture groups - Regex flags (case-insensitive, multiline, etc.) - Unicode support But don't worry about those yet. Master the basics first. You'll be surprised how much you can accomplish with just the patterns in this guide. Now go practice. Our [Regex Tester](/tools/regex-tester) is waiting. **Tools mentioned in this article:** - [Regex Tester](/tools/regex-tester). Test and debug regular expressions

Developer Blog

Featured Post

Building With AI Code Generators: What Actually Works