CODE: Regular Expressions — A Complete Practical Guide

Regex Core Concept:
Pattern:  /\d{4}-\d{2}-\d{2}/
Text:     "Event date: 2025-06-01, Published: 2025-01-15"
Matches:  "2025-06-01" and "2025-01-15"

Pattern: /cat/
Matches: "I have a cat at home"
         ^^^

Pattern: /c.t/  (. matches any character)
Matches: "cat", "cot", "cut", "c3t", "c!t"

Pattern: /c\.t/  (\. matches literal dot)
Matches: "c.t"
Does not match: "cat", "cot"

[abc]    — match 'a', 'b', or 'c'
[^abc]   — match any character EXCEPT 'a', 'b', or 'c'
[a-z]    — match any lowercase letter
[A-Z]    — match any uppercase letter
[0-9]    — match any digit
[a-zA-Z] — match any letter (upper or lower)
[a-zA-Z0-9_] — match any word character

Pattern: /[aeiou]/
Matches: any single vowel

Pattern: /[^0-9]/
Matches: any character that is NOT a digit

Pattern: /\d\d\d/
Matches: any three consecutive digits
Example: "abc123def" → matches "123"

Pattern: /\w+/
Matches: one or more word characters
Example: "hello world" → matches "hello" and "world"

Pattern: /a{2,4}/
Matches: "aa", "aaa", "aaaa"
Does not match: "a" (only 1), "aaaaa" (5, too many)

Pattern: /colou?r/
Matches: "color" and "colour"
(the 'u' is optional)

Pattern: /\d+/
Matches: one or more digits: "1", "42", "1000"

Pattern: /\d*/
Matches: zero or more digits (can match empty string)

Pattern: /<.+>/      (greedy)
Text:    "<b>hello</b>"
Match:   "<b>hello</b>"  (matches everything)

Pattern: /<.+?>/     (lazy, with ?)
Text:    "<b>hello</b>"
Matches: "<b>" and "</b>" (matches as little as possible)

Pattern: /^hello/
Matches: "hello world" (starts with "hello")
Does not match: "say hello" (hello not at start)

Pattern: /world$/
Matches: "hello world" (ends with "world")
Does not match: "world peace" (world not at end)

Pattern: /\bword\b/
Matches: "word" as a whole word
Does not match: "sword" or "words" (word is part of a larger word)

Pattern: /(ab)+/
Matches: "ab", "abab", "ababab"

Pattern: /(cat|dog)/
Matches: "cat" or "dog"

Pattern: /(\w+)\s\1/
Purpose: find repeated words
Text:    "the the quick brown fox"
Match:   "the the"  (word followed by space followed by same word)

Pattern: /(?:cat|dog)s?/
Matches: "cat", "cats", "dog", "dogs"
The ?: prevents capturing the group

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

Breakdown:
[a-zA-Z0-9._%+-]+  — local part (one or more chars)
@                   — literal @ symbol
[a-zA-Z0-9.-]+     — domain name
\.                  — literal dot
[a-zA-Z]{2,}       — TLD (at least 2 letters)

Matches: user@example.com, my.name+tag@domain.co.uk

/\(\d{3}\) \d{3}-\d{4}/

Breakdown:
\(       — literal opening parenthesis
\d{3}    — 3 digits (area code)
\)       — literal closing parenthesis
\s       — space
\d{3}    — 3 digits
-        — literal hyphen
\d{4}    — 4 digits

Matches: (123) 456-7890

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

Breakdown:
https?   — "http" or "https"
:\/\/    — "://" (forward slashes escaped)
(www\.)? — optional "www."
[a-zA-Z0-9.-]+ — domain
\.[a-zA-Z]{2,} — TLD

Matches: https://www.example.com, http://subdomain.site.org

/\d{4}-\d{2}-\d{2}/

Matches: 2025-06-01, 1999-12-31

/\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b/

Matches: 192.168.1.1, 10.0.0.255
Does not match: 999.999.999.999

import re

# Find all email addresses in text
text = "Contact us at support@example.com or sales@example.com."
pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"

emails = re.findall(pattern, text)
print("Emails found:", emails)
# Emails found: ['support@example.com', 'sales@example.com']

# Validate a phone number
phone = "(555) 867-5309"
if re.match(r"^\(\d{3}\) \d{3}-\d{4}$", phone):
    print("Valid phone number")

# Extract date components
date_str = "Today is 2025-06-01"
match = re.search(r"(\d{4})-(\d{2})-(\d{2})", date_str)
if match:
    year, month, day = match.groups()
    print(f"Year: {year}, Month: {month}, Day: {day}")

# Replace matched text
result = re.sub(r"\b\d{4}\b", "XXXX", "My card: 1234 expires 2025")
print(result)  # My card: XXXX expires XXXX

# grep: find lines matching a pattern
grep "\d{3}-\d{4}" phone_numbers.txt

# grep with extended regex (supports +, ?, |)
grep -E "^(ERROR|WARN)" application.log

# grep with Perl-compatible regex
grep -P "\d{4}-\d{2}-\d{2}" log.txt

# sed: find and replace
sed 's/old_pattern/new_text/g' file.txt

# Extract IP addresses from a log
grep -oE "\b([0-9]{1,3}\.){3}[0-9]{1,3}\b" access.log

Catastrophic Backtracking:
Pattern: /^(a+)+$/
Text:    "aaaaaaaaaaaaaaaaaab"

This pattern can take exponential time to fail because
the engine tries every possible combination of the inner
and outer + quantifiers. Known as "ReDoS" (Regex DoS).

+------------------+-------------------------------+
| Pattern          | Matches                       |
+------------------+-------------------------------+
| abc              | Literal "abc"                 |
| .                | Any character (not newline)   |
| \d               | Digit [0-9]                   |
| \w               | Word char [a-zA-Z0-9_]        |
| \s               | Whitespace                    |
| [abc]            | 'a', 'b', or 'c'             |
| [^abc]           | Not 'a', 'b', or 'c'         |
| [a-z]            | Lowercase letter              |
| ^                | Start of line                 |
| $                | End of line                   |
| \b               | Word boundary                 |
| *                | 0 or more                     |
| +                | 1 or more                     |
| ?                | 0 or 1                        |
| {n,m}            | Between n and m               |
| (abc)            | Capture group                 |
| (?:abc)          | Non-capturing group           |
| a|b              | 'a' or 'b'                   |
| \1               | Back-reference to group 1     |
+------------------+-------------------------------+