Regular Expressions in Perl

How It Works

First, the variable when you use the slash character.

$myPattern is declared and assigned the pattern ^\d{5}(-\d{4})?$. Notice that

\d metacharacter and the $ metacharacter, you must precede them with an extra back-

The pattern uses the positional metacharacters ^ and $ to indicate that the pattern must match all of the test string. The pattern matches either a test string of five numeric digits, as indicated by \d{5}, which is the abbreviated form of a U.S. Zip code, or a sequence of five numeric digits, optionally followed by a hyphen and four numeric digits, as indicated by (-\d{4})?, which matches the extended version of a U.S. Zip code. The -\d{4} is grouped inside paired parentheses, so the ? quantifier indicates that all

of -\d{4} is optional:

my $myPattern = “^\\d{5}(-\\d{4})?\$”;

Next, the user is invited to enter a Zip code. The input is captured from the standard input using <STDIN>. And chomp() is used to remove the newline character at the end of $myTestString:

print “Enter a US Zip Code: “; my $myTestString = <STDIN>; chomp ($myTestString);

Then two print statements are used, each with an if statement and corresponding test that determines whether or not anything is displayed. The if statement on the first of the following lines means that the message is output if there is a match. The if statement on the last line causes the text to be displayed if there is no match:

print “You entered a Zip code.\n\n” if ($myTestString =~ m/$myPattern/);

print “The value you entered wasn’t recognized as a US Zip code.” if ($myTestString !~ m/$myPattern/);

Using Other Regular Expression Delimiters

The flexibility of Perl also includes a syntax to specify alternative characters to delimit a regular expression pattern.

The default regular expression delimiters in Perl are paired forward slashes, as in the following:

my $myTestString = “Hello world!”;

$myTestString =~ /world/;

However, Perl allows developers to use other characters as regular expression delimiters, if the m is specified. Personally, I find it easiest to stick with the paired forward slashes almost all the time, but because Perl provides the flexibility to use other characters, it can be confusing interpreting matches or substitutions that use delimiters other than paired forward slashes, if you aren’t aware that Perl allows this flexibility.

675

Chapter 26

The following example shows how matched curly braces, paired exclamation marks, and paired period (dot) characters can be used as regular expression delimiters.

Try It Out

Using Nondefault Delimiters

1.Type the following code into your chosen text editor, and save the code as

NonDefaultDelimiters.pl:

#!/usr/bin/perl -w use strict;

print “This example uses delimiters other than the default /somePattern/.\n\n”; my $myTestString = “Hello world!”;

print “It worked using paired { and }\n\n” if $myTestString =~ m{world}; print “It worked using paired ! and !\n\n” if $myTestString =~ m!world!; print “It worked using paired . and .\n\n” if $myTestString =~ m.world.;

2.Run the code inside or Komodo or at the command line by typing perl NonDefaultDelimiters.pl.

3.Inspect the displayed results, as shown in Figure 26-15. Notice that matched { and }, or paired ! and ! or paired period characters, have all worked, in the sense that they have been used to achieve a successful match.

Figure 26-15

How It Works

After a brief informational message, the string Hello world! is assigned to the variable $myTestString:

my $myTestString = “Hello world!”;

Then the print operator is used three times to print out a message indicating matching using specified delimiters, if the test of an if statement has been satisfied, which it has been in this case.

Matching Using Variable Substitution

If you are new to Perl programming, it may have been surprising that you can include variables inside paired double quotes. You may be even more surprised to learn that you can also include variables inside regular expression patterns.

676

Regular Expressions in Perl

There are two ways variables can be included in patterns, depending on whether or not the variable comes at the end of the pattern.

If the variable comes at the end of the pattern, you can write the following:

/some characters$myPattern/

However, if you want to use the variable at any other position in the pattern, you need to write something like this:

/${myPattern}some other characters/

Try It Out

Matching Using Variable Substitution

1.Type the following code in a text editor:

#!/usr/bin/perl -w use strict;

my $myTestString = “shells”; my $myPattern = “she”;

print “$myPattern is found in $myTestString.\n\n” if ($myTestString =~ m/${myPattern}ll/);

$myTestString = “scar”; $myPattern = “car”;

print “$myPattern is found in $myTestString.\n\n” if ($myTestString =~ m/s$myPattern/);

2.

3.

Save the code as MatchingVariableSubstitution.pl.

Run the code and inspect the results, as shown in Figure 26-16.

Figure 26-16

How It Works

First, look at the variable substitution syntax that can be placed anywhere inside a pattern. You assign values to the $myTestString and $myPattern variables:

my $myTestString = “shells”;

my $myPattern = “she”;

The following line is split only for reasons of presentation on page. Notice the syntax used in the pattern in the test for the if statement. The $myPattern variable is used inside the pattern and is written as ${myPattern}. The paired curly braces allow the name of the pattern to be unambiguously delineated:

677

Chapter 26

print “$myPattern is found in $myTestString.\n\n” if ($myTestString =~

m/${myPattern}ll/);

The second part of this example uses the syntax that can be used only at the end of the pattern. The $myPattern variable is written exactly like that: $myPattern. Because the only use of the second of the paired forward slashes is to delimit the end of the pattern, the meaning is clear:

$myTestString = “scar”; $myPattern = “car”;

print “$myPattern is found in $myTestString.\n\n” if ($myTestString =~ m/s$myPattern/);

As you have seen in this section on matching, there is enormous flexibility in the syntax you can use to achieve matching in Perl.

Using the s/// Operator

The s/// operator is used when a match in the test string is to be replaced by (or substituted with) a replacement string. Search-and-replace syntax takes the following general form:

s/pattern/replacmentText/modifiers

If there is a match, s/// returns the numeric value corresponding to the number of successful matches. The number of matches attempted depends on whether or not the s/// operator is modified by the g (global) modifier. If the g modifier is present, the regular expression engine attempts to find all matches in the test string.

In the following example, the literal pattern Star is replaced by the replacement (substitution) string

Moon.

Try It Out

Using the s/// Operator

1.Type the following code in Komodo or another text editor:

#!/usr/bin/perl -w use strict;

my $myString = “I attended a Star Training Company training course.”; my $oldString = $myString;

$myString =~ s/Star/Moon/;

print “The original string was: \n’$oldString’\n\n”;

print “After replacement the string is: \n’$myString’\n\n”; if ($oldString =~ m/Star/)

{

print “The string ‘Star’ was matched and replaced in the old string”;

}

2.Save the code as SimpleReplace.pl.

3.Either run the code inside Komodo 3.0 or type perl SimpleReplace.pl at the command line, assuming that the file is saved in the current directory or a directory on your machine’s PATH. Inspect the displayed results, as shown in Figure 26-17.

678