Regular Expressions for Beginners — A Practical Guide

1. What Are Regular Expressions?

Regular expressions (regex or regexp) are a powerful pattern-matching language used to search, match, and manipulate text. Think of them as a supercharged "Find & Replace" that can match complex patterns instead of just exact words.

Regex is used everywhere in software development:

• Search & Replace — find and transform text in editors and IDEs
• Form Validation — check if user input matches expected formats (email, phone, URL)
• Data Extraction — pull specific information from logs, HTML, CSV files
• Routing — match URL paths in web frameworks (Express, Django, Flask)
• Log Analysis — filter and parse server logs with tools like grep

Nearly every programming language supports regex: JavaScript, Python, Java, C#, Go, Rust, PHP, Ruby, and more. The syntax is almost identical across all of them.

2. Regex Basics

A regex pattern is a sequence of characters that defines a search pattern. Some characters match themselves (literals), while others have special meanings (metacharacters).

Literal Characters

The simplest regex matches exact text. The pattern hello matches the word "hello" anywhere in a string:

"hello world"   → match: "hello"
"say hello!"    → match: "hello"
"HELLO"         → no match (case-sensitive by default)

Special Characters (Metacharacters)

These characters have special meaning in regex and must be escaped with \ to match them literally:

Character Classes (Shorthand)

Instead of writing long character sets, use these shortcuts:

For example, \d{3}-\d{4} matches a phone-like pattern such as "555-1234".

3. Quantifiers and Anchors

Quantifiers control how many times a pattern should match. Anchors control where a match occurs.

Quantifiers

Anchors and Boundaries

Combine quantifiers with anchors for precise matching. For example, ^\d{5}$ matches a string that is exactly a 5-digit ZIP code and nothing else.

4. Groups and Capturing

Parentheses () serve two purposes: grouping patterns together and capturing matched text for later use.

Capturing Groups

Each pair of parentheses creates a numbered capture group. You can reference the captured text later:

// Pattern: (\d{4})-(\d{2})-(\d{2})
// Input:   "2026-07-20"
// Group 1: "2026"  (year)
// Group 2: "07"    (month)
// Group 3: "20"    (day)

// In JavaScript:
const match = "2026-07-20".match(/(\d{4})-(\d{2})-(\d{2})/);
console.log(match[1]); // "2026"
console.log(match[2]); // "07"
console.log(match[3]); // "20"

Non-Capturing Groups

Use (?:) when you need grouping for quantifiers but do not need to capture the matched text:

// With capturing group (stores "https" or "http"):
/^(https?:)\/\/example\.com$/

// With non-capturing group (groups but does not store):
/^(?:https?:)\/\/example\.com$/

// Non-capturing is slightly more efficient
// and avoids cluttering your capture groups

Backreferences

Use \1, \2, etc. to refer back to a previously captured group. This is useful for matching repeated words:

// Find repeated words:
/(\b\w+\b)\s+\1/

// Matches: "the the", "is is", "hello hello"
// Does not match: "the a", "hello world"

// Example in JavaScript:
"the the cat".match(/(\b\w+\b)\s+\1/);
// Match: "the the", Group 1: "the"

Named Groups

Modern regex supports named groups with (?<name>...) for more readable patterns:

// Named groups for a date pattern:
/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/

// In JavaScript:
const result = "2026-07-20".match(
  /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
);
console.log(result.groups.year);  // "2026"
console.log(result.groups.month); // "07"
console.log(result.groups.day);   // "20"

5. Real-World Examples

Here are practical regex patterns you will use regularly. Each one includes a step-by-step breakdown so you understand every part of the pattern.

Email Address

/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/

• ^ — start of string
• [a-zA-Z0-9._%+-]+ — one or more allowed characters for the local part
• @ — literal @ symbol
• [a-zA-Z0-9.-]+ — domain name (letters, digits, dots, hyphens)
• \.[a-zA-Z]{2,} — dot followed by 2+ letter TLD (.com, .org, .io)
• $ — end of string

// Valid matches:
"[email protected]", "[email protected]"

// Does not match:
"@missing.com", "user@", "[email protected]"

URL

/https?:\/\/(www\.)?[a-zA-Z0-9-]+\.[a-zA-Z]{2,}(\/[^\s]*)?/

• https?: — "http:" or "https:"
• \/\/ — literal "//"
• (www\.)? — optional "www."
• [a-zA-Z0-9-]+ — domain name
• \.[a-zA-Z]{2,} — TLD (.com, .org, etc.)
• (\/[^\s]*)? — optional path (any non-whitespace after /)

Phone Number (US Format)

/^(\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$/

• (\+1[-.\s]?)? — optional country code "+1" with optional separator
• \(?\d{3}\)? — area code, with optional parentheses
• [-.\s]?\d{3} — 3-digit prefix with optional separator
• [-.\s]?\d{4} — 4-digit line number

// Matches: "(555) 123-4567", "555-123-4567", "+1.555.123.4567"

IPv4 Address

/^(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)$/

Each octet uses the same sub-pattern: 25[0-5] (250-255), 2[0-4]\d (200-249), or [01]?\d\d? (0-199). This ensures only valid IP addresses match.

// Valid: "192.168.1.1", "10.0.0.255", "255.255.255.0"
// Invalid: "256.1.1.1", "192.168.1", "10.0.0.0.1"

Date Format (YYYY-MM-DD)

/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/

• \d{4} — 4-digit year
• (0[1-9]|1[0-2]) — month: 01-12
• (0[1-9]|[12]\d|3[01]) — day: 01-31

// Valid: "2026-07-20", "2000-01-01", "1999-12-31"
// Invalid: "2026-13-01", "2026-00-15", "2026-07-32"

6. Practice with Online Tester

The best way to learn regex is by experimenting. Our free Regex Tester tool lets you write patterns and see matches in real time.

Step-by-Step Guide

1. Open the Regex Tester — navigate to /tools/regex-tester.html
2. Enter your test text — paste any text you want to search in the input area
3. Write your pattern — type your regex in the pattern field (no slashes needed)
4. Choose flags — enable g (global) to find all matches, i (case-insensitive), or m (multiline)
5. See highlights — matches are highlighted in the text instantly as you type
6. View groups — capture groups are listed below so you can inspect each part

Practice Exercises

Try these exercises to build your regex skills:

1. Find all numbers in a paragraph — pattern: \d+
2. Extract hashtags from social media text — pattern: #\w+
3. Validate an email — use the email pattern from Section 5
4. Match HTML tags — pattern: <\/?[a-z][a-z0-9]*>
5. Find repeated words — use the backreference pattern: (\b\w+\b)\s+\1

Quick Reference: Common Flags