We’ve been writing patterns in pairs of forward slashes, like /fred/. But this is actually a shortcut for the m// (pattern match) operator. As we saw with the qw// operator, you may choose any pair of delimiters to quote the contents. So, we could write that same expression as m(fred), m<fred>, m{fred}, or m[fred] using those paired delimiters, or as m,fred,, m!fred!, m^fred^, or many other ways using nonpaired delimiters.^[1]

The shortcut is that if you choose the forward slash as the delimiter, you may omit the initial m. Since Perl folks love to avoid typing extra characters, you’ll see most pattern matches written using slashes, as in /fred/.

Of course, you should wisely choose a delimiter that doesn’t appear in your pattern.^[2] If you wanted to make a pattern to match the beginning of an ordinary web URL, you might start to write /^http:/// to match the initial "http://". But that’s easier to read, write, maintain, and debug if you use a better choice of delimiter: m%^http://%.^[3]

It’s common to use curly braces as the delimiter. If you use a programmers’ text editor, it probably has the ability to jump from an opening curly brace to the corresponding closing one, which can be handy in maintaining code.

There are several option modifier letters, sometimes called flags , which may be appended as a group right after the ending delimiter of a regular expression to change its behavior from the default.

print "Would you like to play a game? ";
chomp($_ = <STDIN>);
if (/yes/i) {  # case-insensitive match
  print "In that case, I recommend that you go bowling.
";
}

$_ = "I saw Barney
down at the bowling alley
with Fred
last night.
";
if (/Barney.*Fred/s) {
  print "That string mentions Fred after Barney!
";
}

if (/barney.*fred/si) {  # both /s and /i
  print "That string mentions Fred after Barney!
";
}

Matching against $_ is merely the default; the binding operator (=~) tells Perl to match the pattern on the right against the string on the left, instead of matching against $_.^[5] For example:

my $some_other = "I dream of betty rubble.";
if ($some_other =~ /rub/) {
  print "Aye, there's the rub.
";
}

The first time you see it, the binding operator looks like some kind of assignment operator. But it’s no such thing! It is simply saying, “this pattern match which would attach to $_ by default—make it work with this string on the left instead.” If there’s no binding operator, the expression is using $_ by default.

In the (somewhat unusual) example below, $likes_perl is set to a Boolean value according to what the user typed at the prompt. This is a little on the quick-and-dirty side, because the line of input itself is discarded. This code reads the line of input, tests that string against the pattern, then discards the line of input.^[6] It doesn’t use or change $_ at all.

print "Do you like Perl? ";
my $likes_perl = (<STDIN> =~ /yes/i);
...  # Time passes...
if ($likes_perl) {
  print "You said earlier that you like Perl, so...
";
  ...
}

The parentheses around the pattern-test expression aren’t required, so the following line does the same thing as the one above—it stores the result of the test (and not the line of input) into the variable:

my $likes_perl = <STDIN> =~ /yes/i;

The regular expression is double-quote interpolated, just as if it were a double-quoted string. This allows us to write a quick grep -like program like this:

#!/usr/bin/perl -w
my $what = "larry";

while (<>) {
  if (/^($what)/) {  # pattern is anchored at beginning of string
    print "We saw $what in beginning of $_";
  }
}

The pattern will be built up out of whatever’s in $what when we run the pattern match. In this case, it’s the same as if we had written /^(larry)/, looking for larry at the start of each line.

But we didn’t have to get the value of $what from a literal string; we could have gotten it instead from the command-line arguments in @ARGV:

my $what = shift @ARGV;

Now, if the first command-line argument were fred|barney, the pattern becomes /^(fred|barney)/, looking for fred or barney at the start of each line.^[7] The parentheses (which weren’t really necessary when searching for larry) are important, now, because without them we’d be matching fred at the start or barney anywhere in the string.

With that line changed to get the pattern from @ARGV, this program resembles the Unix grep command. But we have to watch out for metacharacters in the string. If $what contains 'fred(barney', the pattern would look like /^(fred(barney)/, and you know that can’t work right—it’ll crash your program with an invalid regular expression error. With some advanced techniques,^[8] you can trap this kind of error (or prevent the magic of the metacharacters in the first place) so that it won’t crash your program. But for now, just know that if you give your users the power of regular expressions, they’ll also need the responsibility to use them correctly.

Do you remember the regular expression memories, which we used with backreferences in the previous chapter? Those memories are also available after the pattern match is done, after we return to Perl. They’re strings, so they are kept in scalar variables with names like $1 and $2. There are as many of these variables as there are pairs of memory parentheses in the pattern. As you’d expect, $4 means the string matched by the fourth set of parentheses. This is the same string that 4 referred to inside the pattern match.

Why are there two different ways to refer to that same string? They’re not really referring to the same string at the same time; $4 means the fourth memory of an already completed pattern match, while 4 is a backreference referring back to the fourth memory of the currently matching regular expression. Besides, backreferences work inside regular expressions only; once we’re back in the world of Perl, we’ll use $4.

These match variables are a big part of the power of regular expressions, because they let us pull out the parts of a string:

$_ = "Hello there, neighbor";
if (/s(w+),/) {             # memorize the word between space and comma
  print "the word was $1
";  # the word was there
}

Or you could use more than one memory at once:

$_ = "Hello there, neighbor";
if (/(S+) (S+), (S+)/) {
  print "words were $1 $2 $3
";
}

That tells us that the words were Hello there neighbor. Notice that there’s no comma in the output. Because the comma is outside of the memory parentheses in the pattern, there is no comma in memory two. Using this technique, we can choose exactly what we want in the memories, as well as what we want to leave out.

You could even have an empty match variable,^[9] if that part of the pattern might be empty. That is, a match variable may contain the empty string:

my $dino = "I fear that I'll be extinct after 1000 years.";
if ($dino =~ /(d*) years/) {
  print "That said '$1' years.
";  # 1000
}

$dino = "I fear that I'll be extinct after a few million years.";
if ($dino =~ /(d*) years/) {
  print "That said '$1' years.
";  # empty string
}

$wilma =~ /(w+)/;  # BAD! Untested match result
print "Wilma's word was $1... or was it?
";

if ($wilma =~ /(w+)/) {
  print "Wilma's word was $1.
";
} else {
  print "Wilma doesn't have a word.
";
}

if ($wilma =~ /(w+)/) {
  my $wilma_word = $1;
  ...
}

if ("Hello there, neighbor" =~ /s(w+),/) {
  print "That actually matched '$&'.
";
}

if ("Hello there, neighbor" =~ /s(w+),/) {
  print "That was ($`)($&)($').
";
}

print "Matched: |$`<$&>$'|
";  # The three automatic match variables

If you think of the m// pattern match as being like your word processor’s “search” feature, the “search and replace” feature would have to be Perl’s s/// substitution operator. This simply replaces whatever part of a variable^[15] matches a pattern with a replacement string:

$_ = "He's out bowling with Barney tonight.";
s/Barney/Fred/;  # Replace Barney with Fred
print "$_
";

If the match fails, nothing happens, and the variable is untouched:

# Continuing from above; $_ has "He's out bowling with Fred tonight."
s/Wilma/Betty/;  # Replace Wilma with Betty (fails)

Of course, both the pattern and the replacement string could be more complex. Here, the replacement string uses the first memory variable, which is set by the pattern match:

s/with (w+)/against $1/;
print "$_
";  # says "He's out bowling against Fred tonight."

Here are some other possible substitutions. (These are here only as samples; in the real world, it would not be typical to do so many unrelated substitutions in a row.)

$_ = "green scaly dinosaur";
s/(w+) (w+)/$2, $1/;  # Now it's "scaly, green dinosaur"
s/^/huge, /;            # Now it's "huge, scaly, green dinosaur"
s/,.*een//;             # Empty replacement: Now it's "huge dinosaur"
s/green/red/;           # Failed match: still "huge dinosaur"
s/w+$/($`!)$&/;        # Now it's "huge (huge !)dinosaur"
s/s+(!W+)/$1 /;       # Now it's "huge (huge!) dinosaur"
s/huge/gigantic/;       # Now it's "gigantic (huge!) dinosaur"

There’s a return value from s///; it’s true if a substitution was successful; otherwise it’s false:

$_ = "fred flintstone";
if (s/fred/wilma/) {
  print "Successfully replaced fred with wilma!
";
}

$_ = "home, sweet home!";
s/home/cave/g;
print "$_
";  # "cave, sweet cave!"

$_ = "Input  data	 may have    extra whitespace.";
s/s+/ /g;  # Now it says "Input data may have extra whitespace."

s/^s+//;  # Replace leading whitespace with nothing
s/s+$//;  # Replace trailing whitespace with nothing

s#^https://#http://#;

s{fred}{barney};
s[fred](barney);
s<fred>#barney#;

s#wilma#Wilma#gi;  # replace every WiLmA or WILMA with Wilma
s{__END_  _.*}{}s;   # chop off the end marker and all following lines

$file_name =~ s#^.*/##s;  # In $file_name, remove any Unix-style path

$_ = "I saw Barney with Fred.";
s/(fred|barney)/U$1/gi;  # $_ is now "I saw BARNEY with FRED."

s/(fred|barney)/L$1/gi;  # $_ is now "I saw barney with fred."

s/(w+) with (w+)/U$2E with $1/i;  # $_ is now "I saw FRED with barney."

s/(fred|barney)/u$1/ig;  # $_ is now "I saw FRED with Barney."

s/(fred|barney)/uL$1/ig;  # $_ is now "I saw Fred with Barney."

print "Hello, Lu$nameE, would you like to play a game?
";

Another operator that uses regular expressions is split , which breaks up a string according to a separator. This is useful for tab-separated data, or colon-separated, whitespace-separated, or anything-separated data, really.^[21] So long as you can specify the separator with a regular expression (and generally, it’s a simple regular expression), you can use split. It looks like this:

@fields = split /separator/, $string;

The split operator^[22] drags the pattern through a string and returns a list of fields (substrings) that were separated by the separators. Whenever the pattern matches, that’s the end of one field and the start of the next. So, anything that matches the pattern will never show up in the returned fields. Here’s a typical split pattern, splitting on colons:

@fields = split /:/, "abc:def:g:h";  # gives ("abc", "def", "g", "h")

You could even have an empty field, if there were two delimiters together:

@fields = split /:/, "abc:def::g:h";  # gives ("abc", "def", "", "g", "h")

Here’s a rule that seems odd at first, but it rarely causes problems: Leading empty fields are always returned, but trailing empty fields are discarded:^[23]

@fields = split /:/, ":::a:b:c:::";  # gives ("", "", "", "a", "b", "c")

It’s also common to split on whitespace, using /s+/ as the pattern. Under that pattern, all whitespace runs are equivalent to a single space:

my $some_input = "This  is a 	        test.
";
my @args = split /s+/, $some_input;  # ("This", "is", "a", "test.")

The default for split is to break up $_ on whitespace:

my @fields = split;  # like split /s+/, $_;

This is almost the same as using /s+/ as the pattern, except that a leading empty field is suppressed—so, if the line starts with whitespace, you won’t see an empty field at the start of the list. (If you’d like to get the same behavior when splitting another string on whitespace, just use a single space in place of the pattern: split ' ', $other_string. Using a space instead of the pattern is a special kind of split.)

Generally, the patterns used for split are as simple as the ones you see here. But if the pattern becomes more complex, be sure to avoid using memory parentheses in the pattern; see the perlfunc manpage for more information.^[24]

The join function doesn’t use patterns. So why is it in this chapter? It’s here because, in a sense, join performs the opposite function of split : split breaks up a string into a number of pieces, and join glues together a bunch of pieces to make a single string. The join function looks like this:

my $result = join $glue, @pieces;

The first argument to join is the glue, which may be any string. The remaining arguments are a list of pieces. join puts the glue string between the pieces and returns the resulting string:

my $x = join ":", 4, 6, 8, 10, 12;  # $x is "4:6:8:10:12"

In that example, we had five items, so there are only four colons. That is, there are four pieces of glue. The glue shows up only between the pieces, never before or after them. So, there will be one fewer piece of glue than the number of items in the list.

This means that there may be no glue at all, if the list doesn’t have at least two elements:

my $y = join "foo", "bar";       # gives just "bar", since no fooglue is needed
my @empty;                       # empty array
my $empty = join "baz", @empty;  # no items, so it's an empty string

Using $x from above, we can break up a string and put it back together with a different delimiter:

my @values = split /:/, $x;  # @values is (4, 6, 8, 10, 12)
my $z = join "-", @values;   # $z is "4-6-8-10-12"

Although split and join work well together, don’t forget that the first argument to join is always a string, not a pattern.

See Section A.8 for answers to the following exercises: