bug-ops/zeph/regex

Regular Expressions Reference

Quick Reference

Character Classes

Shorthand Classes

POSIX Classes (use inside [...])

Usage: [[:alpha:]] (double brackets when inside a character class).

Custom Character Classes

[aeiou]          # Vowels
[a-z]            # Lowercase letters
[A-Z]            # Uppercase letters
[0-9]            # Digits
[a-zA-Z0-9]     # Alphanumeric
[^aeiou]         # NOT vowels
[a-z&&[^m-r]]   # a-z except m-r (intersection, Java/Rust)
[-.]             # Literal hyphen and dot (hyphen first or last)
[\\^]            # Literal backslash and caret

Quantifiers

Greedy (match as much as possible)

Lazy (match as little as possible)

Add ? after the quantifier:

Example difference:

Input:   <b>bold</b> and <b>more</b>
Greedy:  <b>.*</b>     matches "<b>bold</b> and <b>more</b>"
Lazy:    <b>.*?</b>    matches "<b>bold</b>" then "<b>more</b>"

Possessive (no backtracking, PCRE/Java)

Add + after the quantifier: *+, ++, ?+

Possessive quantifiers never give back matched characters, which prevents catastrophic backtracking but may cause the match to fail where greedy would succeed.

Anchors

\bword\b     # "word" as a whole word
^line$       # Entire line equals "line"
\Afirst      # "first" at the very start of the string

Groups

Capturing Groups

(abc)            # Capture group 1
(a)(b)(c)        # Groups 1, 2, 3
(a(b)c)          # Nested: group 1 = "abc", group 2 = "b"

Named Groups

(?P<name>pattern)    # Python, PCRE (also (?<name>pattern) in PCRE2)
(?<name>pattern)     # JavaScript, .NET, Rust, Java, PCRE2

Non-Capturing Groups

(?:abc)              # Group without capturing

Backreferences

(foo)\1              # Match "foo" followed by "foo" again
(?P<word>\w+)\s+\k<word>   # Named backreference (PCRE)
\1, \2, \3           # Numbered backreferences

Lookaround Assertions

Lookaround matches a position without consuming characters (zero-width).

Lookahead

foo(?=bar)       # "foo" followed by "bar" (positive lookahead)
foo(?!bar)       # "foo" NOT followed by "bar" (negative lookahead)

Lookbehind

(?<=foo)bar      # "bar" preceded by "foo" (positive lookbehind)
(?<!foo)bar      # "bar" NOT preceded by "foo" (negative lookbehind)

Lookbehind restrictions: in most flavors (PCRE, Python, JavaScript), lookbehind must have a fixed length. Variable-length lookbehind is supported in .NET, Java 13+, and Python's regex module.

Practical Examples

# Password: at least one digit, one uppercase, one lowercase
^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,}$
 
# Number NOT followed by "px"
\d+(?!px)
 
# Dollar amount
(?<=\$)\d+(\.\d{2})?
 
# Word between quotes
(?<=")([^"]+)(?=")

Alternation

cat|dog              # "cat" or "dog"
(cat|dog) food       # "cat food" or "dog food"
colou?r              # "color" or "colour"
gr[ae]y              # "gray" or "grey"

Flags / Modifiers

Inline flags (within pattern):

(?i)pattern          # Case insensitive
(?im)pattern         # Case insensitive + multiline
(?i:pattern)         # Scoped to group only

Common Patterns

Email Address (simplified)

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

URL

https?://[^\s/$.?#][^\s]*

IPv4 Address

\b(?:\d{1,3}\.){3}\d{1,3}\b

Strict (0-255 per octet):

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

IPv6 Address (simplified)

(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}

Date (YYYY-MM-DD)

\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])

Time (HH:MM:SS, 24h)

(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d

Phone Number (US)

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

Hex Color

#(?:[0-9a-fA-F]{3}){1,2}\b

Semantic Version

\bv?(\d+)\.(\d+)\.(\d+)(?:-([\w.]+))?(?:\+([\w.]+))?\b

UUID

[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}

File Path (Unix)

(?:/[\w.-]+)+/?

Whitespace Normalization

\s+         # Match consecutive whitespace (for replacement with single space)
^\s+|\s+$   # Leading or trailing whitespace (for trimming)

Flavor Differences

Key flavor notes

• Rust (`regex` crate): no backreferences, no lookaround (use fancy-regex for those). Guaranteed linear time.
• JavaScript: lookbehind added in ES2018 (modern browsers). No possessive quantifiers or atomic groups.
• Python: re module has fixed-length lookbehind. regex module (third-party) supports variable-length lookbehind.
• POSIX BRE: requires escaping (, ), {, } — they are literal without backslash. Used by grep (default), sed.
• POSIX ERE: (, ), {, } are special without backslash. Used by grep -E, awk, sed -E.

Testing Strategies

# Test with grep (POSIX BRE)
echo "test123" | grep '[0-9]\+'
 
# Test with grep -E (ERE) or grep -P (PCRE, GNU grep)
echo "test123" | grep -E '[0-9]+'
echo "test123" | grep -P '\d+'
 
# Test with sed
echo "2024-01-15" | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/'
 
# Test with Python
python3 -c "import re; print(re.findall(r'\d+', 'abc123def456'))"
 
# Test with Rust
# In code: regex::Regex::new(r"\d+").unwrap().find("abc123")
 
# Online tools: regex101.com (supports PCRE, JS, Python, Go, Rust)

Performance Tips

• Avoid catastrophic backtracking: (a+)+b on "aaaaaac" causes exponential time
• Use possessive quantifiers (++) or atomic groups ((?>...)) when available
• Anchored patterns (^...$) are faster than unanchored
• Character classes [aeiou] are faster than alternation a|e|i|o|u
• Avoid .* at the start of a pattern; use a more specific prefix
• Pre-compile regex objects when matching in a loop (all languages)
• Use non-capturing groups (?:...) when you do not need the captured text
• Rust's regex crate guarantees O(n) matching; if you need backreferences, use fancy-regex but be aware of potential exponential time

Important Notes

• Always use raw strings in programming languages to avoid double-escaping: Python r"\d+", Rust r"\d+"
• \b matches a position between a word character and a non-word character, not a character itself
• . does not match \n by default; enable dotall/single-line mode (s flag) if needed
• ^ and $ match start/end of string by default; enable multiline mode (m flag) for line boundaries
• In character classes, most special characters lose their meaning: [.] matches a literal dot
• Hyphen in character class must be first, last, or escaped: [a-z] is a range, [-az] includes literal -
• Caret ^ negates a character class only when it is the first character: [^abc]
• Always test regex against edge cases: empty strings, very long inputs, Unicode, special characters