Regex Tutorial for Beginners

1. What Is a Regular Expression?

A regular expression (regex) is a sequence of characters that defines a search pattern. Think of it as a miniature programming language for finding, extracting, and manipulating text.

Every developer encounters regex sooner or later — whether you're validating an email address, extracting data from a log file, finding all phone numbers in a document, or replacing text across thousands of files. Regex is one of those skills that pays for itself a hundred times over.

What Can You Do With Regex?

• Validate — Is this email address format valid? Is this phone number real?
• Search — Find all URLs, dates, or IP addresses in a document.
• Extract — Pull the username from an email, the error code from a log line.
• Replace — Change date formats, mask credit card numbers, clean up data.
• Split — Break a string into parts by a pattern rather than a fixed character.

2. Literal Characters — The Simplest Pattern

The most basic regex is a literal character. The pattern cat matches the letters c, a, t in that exact order. It's like a search function — but regex is anywhere in the string by default.

Literal characters are case-sensitive by default. Cat does not match cat. Most regex engines let you enable a case-insensitive flag (usually i).

3. Character Classes — Matching a Set of Characters

Sometimes you want to match any one of several characters. Character classes let you do that using square brackets [...].

Shorthand Character Classes

Because character classes are so common, regex has shorthand versions:

# Example: Find all prices in a text
Pattern: \d+\.\d{2}
Text:    "Apples cost 2.99, bananas 1.49, oranges 3.00"
Matches: 2.99, 1.49, 3.00

4. Quantifiers — How Many Times?

Quantifiers tell regex how many times a character or group should appear. They come after the thing they apply to.

Greedy vs. Lazy Matching

By default, quantifiers are greedy — they match as much as possible. Adding a ? after the quantifier makes it lazy — it matches as little as possible.

Text:    <div>Hello</div><div>World</div>
Pattern: <.+>   (greedy — matches the whole string)
Pattern: <.+?>  (lazy — matches each tag individually)
Match 1: <div>  (lazy finds each one)
Match 2: </div>
Match 3: <div>
Match 4: </div>

5. Anchors — Where in the String?

Anchors don't match characters — they match positions in the string.

When to Use Anchors

Anchors are essential for validation. Without them, a pattern like \d{5} will match any five-digit sequence anywhere — including inside a ten-digit number. With anchors, ^\d{5}$ ensures the entire string is exactly five digits.

# Without anchors — matches anywhere
Pattern: \d{5}
Text:    "zip 90210 code"
Match:   90210  — but also finds 5 digits inside longer numbers

# With anchors — matches only whole string
Pattern: ^\d{5}$
Text:    "90210"
Match:   90210 

Text:    "90210-1234"
Match:   No match  (because the string has more than 5 chars)

6. The Wildcard — Matching Anything

The dot . matches any single character except a newline. It's regex's wildcard.

Combined with quantifiers, the dot is extremely powerful — and dangerous:

Pattern: .*     — matches everything (entire string)
Pattern: .+     — matches everything except empty strings
Pattern: .{3,}  — matches any string of 3+ characters

7. Escaping Special Characters

What if you want to match a literal dot, asterisk, or dollar sign? Since these characters have special meaning in regex, you need to escape them with a backslash \.

Special characters that need escaping when you want them literally: \. ^ $ * + ? { } [ ] \ | ( )

8. Groups and Capturing

Parentheses (...) serve two purposes in regex: they group parts of a pattern together, and they capture the matched text for later use.

Capturing Groups

Pattern: (\w+)@(\w+)\.(\w+)
Text:    "[email protected]"
Group 1: user
Group 2: example
Group 3: com

Each pair of parentheses creates a capture group. You can reference these groups by number: $1, $2, etc. This is incredibly useful for replacements.

# Replace: Swap first and last name
Pattern:   (\w+), (\w+)
Replace:   $2 $1
Text:      "Doe, John"
Result:    "John Doe"

Non-Capturing Groups

Sometimes you need to group but don't want to capture. Use (?:...) instead:

Pattern: (?:Mr|Mrs|Ms)\.?\s(\w+)
Text:    "Mr. Smith" and "Mrs Jones"
Group 1: Smith, Jones  (only the name is captured, not the title)

Backreferences

Inside the same pattern, \1, \2 refer back to previously captured groups. This is useful for finding repeated words or matching paired HTML tags:

# Find repeated words
Pattern: (\w+) \1
Text:    "the the"
Match:   the the 

# Match opening and closing HTML tags
Pattern: <(\w+)>.*?
Text:    "<b>bold</b> and <i>italic</i>"
Matches: <b>bold</b>, <i>italic</i>

9. Alternation — This or That

The pipe | acts like an OR operator. It matches the pattern on either side.

Pattern: cat|dog
Text:    "I have a cat and a dog"
Matches: cat, dog

Alternation is often combined with groups to limit the scope:

Pattern: (apple|banana) pie
Text:    "apple pie is better than banana pie"
Matches: apple pie, banana pie

# Without parentheses, the pipe applies to the whole pattern
Pattern: apple|banana pie
Text:    "apple pie"
Match:   apple (just "apple", not "apple pie")

10. Lookahead and Lookbehind

Lookaheads and lookbehinds are zero-width assertions — they check if a pattern can be matched without including it in the result. Think of them as "peek ahead" or "peek behind" without consuming characters.

Lookahead (?=...)

Matches if the pattern inside follows the current position, but doesn't include it:

Pattern: \d+(?= dollars)
Text:    "50 dollars, 30 euros"
Matches: 50 (only "50", not "dollars")

Negative Lookahead (?!...)

Matches if the pattern inside does not follow:

Pattern: \d+(?! dollars)
Text:    "50 dollars, 30 euros"
Matches: 30 (only "30", not "euros")

Lookbehind (?<=...)

Matches if the pattern inside precedes the current position:

Pattern: (?<=\$)\d+
Text:    "Price: $50, Cost: 30"
Matches: 50 (only the number after $)

Negative Lookbehind (?

Pattern: (?


Practical use: Lookarounds are perfect for extracting values without including the surrounding context. For example, extracting prices: (?<=\$)\d+\.?\d* finds all dollar amounts and returns just the number.