Mastering Regular Expressions

A Complete Guide for Developers Across Languages and Platforms

Introduction: Why Regular Expressions Matter

1. What This Book Covers
2. Languages and Engines Covered
3. How to Use This Book
4. A Note on Notation

Chapter 1: What Are Regular Expressions?

1. The Power of Pattern Matching
2. A Brief History: From Automata Theory to grep
3. What Regex Can and Cannot Do
4. How This Book Is Organized: Your Learning Roadmap

Chapter 2: Your First Regular Expressions

1. Literal Characters and Exact Matches
2. Writing Your First Pattern
3. The Anatomy of a Regex Operation
4. Testing Patterns Interactively

Chapter 3: Metacharacters and Escaping

1. The Dot Metacharacter
2. Special Characters That Need Escaping
3. Escape Sequences for Common Characters
4. When Escaping Behavior Differs Across Engines

Chapter 4: Character Classes and Ranges

1. Defining Character Sets with Square Brackets
2. Ranges and Ordering Within Classes
3. Negated Character Classes
4. Shorthand Character Classes
5. POSIX Character Classes

Chapter 5: Quantifiers and Repetition

1. The Asterisk, Plus, and Question Mark
2. Exact and Range Quantifiers
3. Greedy Matching Explained
4. Common Quantifier Mistakes

Chapter 6: Anchors and Boundaries

1. Start and End of String Anchors
2. Word Boundaries
3. Line Anchors and Multiline Mode
4. Zero-Width Assertions vs Consuming Characters

Chapter 7: Alternation and Grouping

1. The Pipe Operator for Alternation
2. Capturing Groups with Parentheses
3. Non-Capturing Groups
4. Prioritizing Alternatives

Chapter 8: Backreferences and Named Groups

1. Numeric Backreferences
2. Named Capture Groups
3. Backreferences in Replacement Strings
4. Engine Support Variations

Chapter 9: Lookahead and Lookbehind Assertions

1. Positive Lookahead
2. Negative Lookahead
3. Positive Lookbehind
4. Negative Lookbehind
5. Fixed-Length vs Variable-Length Lookbehind

Chapter 10: Greedy, Lazy, and Possessive Quantifiers

1. Understanding Greedy Behavior Step by Step
2. Lazy (Reluctant) Quantifiers
3. Possessive Quantifiers and Their Performance Benefits
4. Choosing the Right Quantifier Mode

Chapter 11: Atomic Groups and Advanced Assertions

1. Atomic Groups and Backtracking Control
2. Conditional Patterns
3. Recursive and Balanced Matching
4. Engine-Specific Features

Chapter 12: Unicode and International Text

1. Unicode Code Points vs Bytes
2. Unicode Property Escapes
3. Case Insensitivity Across Languages
4. Grapheme Clusters and Combining Characters

Chapter 13: Matching, Searching, Extracting, Replacing

1. Full Match vs Search vs Find All
2. Extracting Captured Groups
3. Splitting Strings on Patterns
4. Replacement with Backreferences

Chapter 14: Real-World Pattern Recipes

1. Email Address Validation
2. URL and URI Matching
3. Date and Time Patterns
4. File Paths and Filenames
5. Log Line Parsing

Chapter 15: Source Code and Structured Text Processing

1. Tokenizing Source Code
2. Parsing Configuration Files
3. Working with Markup Languages
4. When to Use a Parser Instead

Chapter 16: Debugging and Testing Regex

1. Interactive Testing Tools
2. Writing Unit Tests for Regex
3. Step-by-Step Debugging Techniques
4. Common Pitfalls and How to Spot Them

Chapter 17: Performance and Security

1. Understanding Backtracking Cost
2. Catastrophic Backtracking Explained
3. Regular Expression Denial of Service (ReDoS)
4. Writing Linear-Time Patterns with RE2

Chapter 18: Maintainability, Portability, and Best Practices

1. Readable Regex: Comments and Formatting
2. Porting Patterns Across Engines
3. When Not to Use Regular Expressions
4. Documentation and Team Standards

Chapter 19: Regex Engines and Flavors Compared

1. NFA vs DFA vs Hybrid Engines
2. Engine Feature Comparison Table
3. Unicode Handling Differences
4. Performance Characteristics

Chapter 20: Language-Specific API Guides

1. Python (re and regex modules)
2. Perl (m//, s///, qr//)
3. Ruby (Regexp class)
4. Go (regexp package)
5. Rust (regex crate)
6. C (POSIX regex.h and PCRE2)
7. C++ (std::regex)
8. Java (java.util.regex)
9. C# (.NET System.Text.RegularExpressions)

Chapter 21: Putting It All Together

1. The Regex Decision Framework
2. Building Your Pattern Library
3. Continuing Your Learning Journey
4. Final Thoughts

Glossary of Terms

Syntax and Metacharacter Cheat Sheet

1. Core Metacharacters
2. Quantifiers
3. Shorthand Character Classes
4. Common Escape Sequences

Common Patterns Reference

1. Validation Patterns
2. Extraction Patterns
3. Transformation Patterns

Troubleshooting Guide

1. Pattern does not match expected input
2. Pattern matches too much (greedy problem)
3. Pattern is very slow or hangs
4. Pattern works in one language but not another
5. Unicode-related issues

Further Reading and Bibliography

1. Books
2. Papers and Technical Articles
3. Official Documentation
4. Standards
5. Online Tools

References