Regular Expressions in Perl

Our program demonstrates common regular expression tasks in Perl. Here’s the full source code:

use strict;
use warnings;
use feature 'say';

# This tests whether a pattern matches a string.
my $match = "peach" =~ /p([a-z]+)ch/;
say $match ? "true" : "false";

# We'll use this pattern for the following examples
my $pattern = qr/p([a-z]+)ch/;

# This is equivalent to the MatchString method in Go
say $pattern =~ /peach/ ? "true" : "false";

# This finds the match for the regexp.
if ("peach punch" =~ $pattern) {
    say $&;
}

# This also finds the first match but returns the
# start and end indexes for the match instead of the
# matching text.
if ("peach punch" =~ $pattern) {
    say "idx: [$-[0], $+[0]]";
}

# The capturing parentheses in the pattern allow us to extract
# submatches. This is similar to FindStringSubmatch in Go.
if ("peach punch" =~ $pattern) {
    say "[$&, $1]";
}

# To get all matches (like FindAllString in Go), we use the /g flag
my @matches = "peach punch pinch" =~ /$pattern/g;
say "[" . join(", ", @matches) . "]";

# To limit the number of matches, we can use a loop
my @limited_matches;
while ("peach punch pinch" =~ /$pattern/g) {
    push @limited_matches, $&;
    last if @limited_matches == 2;
}
say "[" . join(", ", @limited_matches) . "]";

# Perl's regexes work on both strings and binary data by default

# When creating global variables with regular expressions,
# you can use the qr// operator to pre-compile the regex
my $r = qr/p([a-z]+)ch/;
say "regexp: $r";

# The s/// operator can be used to replace subsets of strings
my $replaced = "a peach";
$replaced =~ s/$r/<fruit>/;
say $replaced;

# We can also use a function to transform matched text
my $transformed = "a peach";
$transformed =~ s/$r/uc($&)/e;
say $transformed;

To run the program, save it as regular-expressions.pl and use perl:

$ perl regular-expressions.pl
true
true
peach
idx: [0, 5]
[peach, ea]
[peach, punch, pinch]
[peach, punch]
regexp: (?^:p([a-z]+)ch)
a <fruit>
a PEACH

Perl has built-in support for regular expressions as a core language feature. Unlike Go, which uses a separate package for regex operations, Perl integrates regex syntax directly into the language.

The =~ operator is used for matching regexes against strings. The // delimiters define a regex pattern. The /g flag is used for global matching (finding all occurrences).

Perl uses special variables like $& (the entire match), $1, $2, etc. (capturing groups), and $-[0], $+[0] (start and end positions of the match) to provide information about matches.

The qr// operator pre-compiles a regex for efficiency when it’s used multiple times.

The s/// operator is used for substitutions, similar to ReplaceAllString in Go. The /e flag allows the replacement to be a Perl expression, which is evaluated for each match.

For a complete reference on Perl regular expressions, consult the official Perl documentation.

Text Templates in Perl

Random Numbers in Perl

Learn X By Example

Title here

Regular Expressions in Perl