Regular Expressions in Perl

Analogy categoryAnalogies

Understanding Regular Expressions in Perl

Regular expressions are woven directly into Perl's syntax rather than bolted on as a library, which is why Perl earned its reputation as the premier text-processing language of the 1990s web. A pattern is written between slashes, such as /foo/, and can be bound to a variable with the =~ operator to test whether that variable contains a matching substring. This tight integration means pattern matching reads almost like natural language inside conditionals and loops.

🏏

Cricket analogy: Just as a commentator instantly recognizes a googly by its wrist action without consulting a rulebook, Perl recognizes a pattern match inline with =~ without needing a separate function call, keeping the syntax fast and immediate.

Matching Basics: Pattern Binding and Metacharacters

The building blocks of a Perl pattern are metacharacters: . matches any character except newline, * means zero or more of the preceding token, + means one or more, ? means zero or one, and \d, \w, \s match digits, word characters, and whitespace respectively. Anchors ^ and $ pin a match to the start or end of a string (or line, in multiline mode), while character classes like [aeiou] match any one character from a defined set. Combining these lets you write compact patterns such as /^\d{3}-\d{4}$/ to validate a phone extension format.

🏏

Cricket analogy: Just as a bowler combines line and length, a yorker on off stump versus a bouncer, to build a specific delivery, a Perl programmer combines anchors and quantifiers like ^\d{3} to build a specific matching delivery for text.

perl

my $line = "Order-4521 shipped on 2026-07-10";

if ($line =~ /Order-(\d+)/) {
    print "Order number: $1\n";  # Order number: 4521
}

if ($line =~ /(\d{4})-(\d{2})-(\d{2})/) {
    print "Year: $1, Month: $2, Day: $3\n";
}

Capturing Groups and Backreferences

Parentheses in a pattern create capturing groups, and after a successful match Perl populates $1, $2, $3 and so on with the text each group matched, in left-to-right order of the opening parenthesis. This is enormously useful for extracting structured pieces out of unstructured text, such as pulling the year, month, and day out of a date string in one match instead of three separate substring operations. Named captures, written as (?<year>\d{4}), store the same value in %+{year}, which makes long patterns with many groups far more readable than counting parentheses by hand.

🏏

Cricket analogy: Just as a scorecard breaks an innings into overs, then balls, then runs per ball for easy review, capturing groups break a matched string into $1, $2, $3 for easy review after the match.

Named captures, (?<name>...), are preferred in long or maintained patterns because %+{name} is self-documenting, whereas $3 forces a reader to count opening parentheses to know what it represents.

Substitution with s/// and Modifiers

The substitution operator s/PATTERN/REPLACEMENT/ finds text matching PATTERN and replaces it with REPLACEMENT, modifying the bound variable in place. Inside REPLACEMENT you can reference captured groups from PATTERN, so s/(\w+)\s+(\w+)/$2 $1/ swaps two space-separated words. Adding the /e modifier evaluates REPLACEMENT as executable Perl code rather than a literal string, which is powerful for computed substitutions like s/(\d+)/$1*2/e to double every number found in a string, but it should be used carefully since it runs arbitrary code.

🏏

Cricket analogy: Just as a captain swaps a bowler mid-over after a string of no-balls, s/// swaps a matched substring for a replacement mid-string, changing the outcome without replaying the whole innings.

perl

my $text = "Prices: 10, 25, 7";
$text =~ s/(\d+)/$1*2/ge;
print "$text\n";  # Prices: 20, 50, 14

my $name = "Doe John";
$name =~ s/(\w+)\s+(\w+)/$2 $1/;
print "$name\n";  # John Doe

The /e modifier compiles the replacement side as real Perl code and executes it. Never use /e on a pattern or replacement built from untrusted user input, since it opens the same code-injection risk as eval().

Common Regex Modifiers (g, i, m, s, x)

Modifiers appended after the closing delimiter change how a pattern behaves: /g makes a match or substitution global, finding all occurrences instead of just the first; /i makes matching case-insensitive; /m changes ^ and $ to match at the start and end of every line within a multiline string rather than only the whole string; /s makes . match newlines too; and /x allows whitespace and comments inside the pattern for readability. Combining /x with a pattern spread across multiple lines turns a dense expression like /^(\d{3})-(\d{4})$/ into a self-documenting block with inline comments explaining each piece.

🏏

Cricket analogy: Just as a fielding restriction rule (powerplay) changes how the same eleven players are allowed to position themselves for the first six overs, a modifier like /m changes how the same pattern is allowed to match across a multiline string.

Pattern binding uses =~ (match) or !~ (does not match) to test a variable against a regex.
Metacharacters . * + ? \d \w \s and anchors ^ $ form the core building blocks of a pattern.
Parentheses create capturing groups populated into $1, $2, ...; named captures use (?<name>...) and %+{name}.
s/PATTERN/REPLACEMENT/ performs substitution in place; the /e modifier evaluates the replacement as Perl code.
The /g modifier matches or replaces globally instead of stopping at the first occurrence.
/i ignores case, /m changes line anchors, /s makes . match newlines, and /x allows readable, commented patterns.
Never apply /e to patterns built from untrusted input, since it executes arbitrary code.