Regular Expressions in Perl

The $& variable is used to display the whole match, in this case, the character sequence B9:

print “The whole match is ‘$&’, contained in the \$& variable.\n”;

The group captured by the first pair of parentheses matches the character class [A-Z]. In this case, the variable $1 holds the single character B:

print “The first captured group is ‘$1’, contained in ‘\$1’.\n”;

The group captured by the second pair of parentheses matches against the metacharacter \d. In this case the variable $2 holds the value 9:

print “The second captured group is ‘$2’, contained in ‘\$2’\n”;

Using Back References in Perl

Perl supports the use of back references, which are references to captured groups that can be used from inside the regular expression pattern.

A classic example of the use of back references is in the identification and correction of doubled words in text. The following example illustrates the use of back references for that purpose.

Try It Out

Using Back References to Detect Doubled Words

1.Type the following code into a text editor:

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

my $myPattern = “(\\w+)(\\s+\\1\\b)”;

my $myTestString = “Paris in the the Spring Spring.”; print “The original string was ‘$myTestString’.\n”; $myTestString =~ s/$myPattern/$1/g;

print “The captured group was: ‘$1’.\n”;

print “Any doubled word has now been removed.\n”; print “The string is now ‘$myTestString’.\n”;

2.Save the code as DoubledWord.pl.

3.Run the code, and inspect the displayed result, as shown in Figure 26-23. Notice in the original test string that two words were doubled: the and Spring. In the replacement string, both doubled words have been removed.

Figure 26-23

689

Chapter 26

How It Works

The pattern is assigned to the variable $myPattern. The metacharacters \w, \s, and \b have to be written with an extra backslash.

Note that the back reference \1 must also be written with an extra backslash:

my $myPattern = “(\\w+)(\\s+\\1\\b)”;

The test string Paris in the the Spring Spring. has two pairs of doubled words:

my $myTestString = “Paris in the the Spring Spring.”;

The original string containing the doubled words is displayed to the user:

print “The original string was ‘$myTestString’.\n”;

The back reference $1 is used with the s/// operator.

In the pattern, the component (\w+) captures the first word in $1. The remainder of the match is in $2, which is discarded.

The g modifier means that all occurrences of doubled words will be replaced:

$myTestString =~ s/$myPattern/$1/g;

Information about the first captured group, the effect of the replacement, and the result of the replacement is displayed to the user:

print “The captured group was: ‘$1’.\n”;

print “Any doubled word has now been removed.\n”; print “The string is now ‘$myTestString’.\n”;

Using Alternation

Alternation allows specific options to be matched. The pipe character, |, is used to express alternation.

Try It Out

Using Alternation

1.Type the following code into a text editor, and save it as Alternation.pl:

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

my $myPattern = “(Jim|Fred|Alice)”; print “Enter your first name here: \n”; my $myTestString = <STDIN>; chomp($myTestString);

if ($myTestString =~ m/$myPattern/)

{

print “Hello $&. How are you?”;

}

else

690

Regular Expressions in Perl

{

print “I am sorry, $myTestString. I don’t know you.”;

}

2.Run the code, enter the name Alice, and inspect the displayed results.

3.Run the code again; enter the name Andrew; and inspect the displayed results, as shown in Figure 26-24.

Figure 26-24

How It Works

The $myPattern variable is assigned a pattern that uses the pipe character to specify three literal patterns as options:

my $myPattern = “(Jim|Fred|Alice)”;

The user is asked to enter his or her first name:

print “Enter your first name here: \n”;

A line of characters from the standard input is assigned to the $myTestString variable:

my $myTestString = <STDIN>;

The chomp() operator is used to remove the newline character at the end of $myTestString:

chomp($myTestString);

If the name entered by the user is one of the three specified options, a message greeting the user is displayed:

if ($myTestString =~ m/$myPattern/)

{

print “Hello $&. How are you?”;

}

However, if the name entered is not one of the three permitted options, the user is told that he or she is not known:

else

{

print “I am sorry, $myTestString. I don’t know you.”;

}

691

Chapter 26

Using Character Classes in Perl

Perl supports an extensive range of character class functionality. If you want to specify individual characters to be matched, you simply list those inside a character class.

Metacharacters inside character classes are different from metacharacters outside them. Outside a character class, the ^ metacharacter matches a position before the first character of a string or line (depending on settings). Inside a character class, the ^ metacharacter, when it is the first character after the left square bracket, indicates a negated character class. All the characters after the ^ are characters that do not match.

Try It Out

Using a Character Class

1.Type the following code in a text editor, and save it as CharacterClass.pl:

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

print “Enter a character class to be used as a pattern: “; my $myPattern = <STDIN>;

print “\n\nEnter a string to test against the character class: “; my $myTestString = <STDIN>;

chomp ($myPattern); chomp ($myTestString);

print “\n\nThe string you entered was: ‘$myTestString’.\n”; print “The pattern you entered was: ‘$myPattern’.\n”;

if ($myTestString =~ m/$myPattern/)

{

print “There was a match: ‘$&’.\n”;

}

else

{

print “There was no match.”;

}

2.Run the code.

3.Enter the pattern [A-Z][a-z]*.

4.Enter the test string Hello world!, and inspect the displayed results.

5.Run the code again.

6.Enter the pattern [A-E][a-z]*.

7.Enter the test string Hello Ethel. How are you?, and inspect the displayed results, as shown in Figure 26-25.

692

Regular Expressions in Perl

Figure 26-25

How It Works

The user is invited to enter a pattern to be matched against:

print “Enter a character class to be used as a pattern: “;

A line of characters from the standard input is assigned to the $myPattern variable:

my $myPattern = <STDIN>;

The user is then invited to enter a test string. The test string is captured from the standard input and is assigned to the $myTestString variable:

print “\n\nEnter a string to test against the character class: “;

my $myTestString = <STDIN>;

Then the chomp() operator is used to remove the terminal newline character from $myPattern and from $myTestString:

chomp ($myPattern);

chomp ($myTestString);

The pattern and test string are displayed to ensure that the user is aware of both. The user should identify any typos from that information:

print “\n\nThe string you entered was: ‘$myTestString’.\n”;

print “The pattern you entered was: ‘$myPattern’.\n”;

An if statement uses a matching process to determine whether a message about success or failure of matching has occurred:

if ($myTestString =~ m/$myPattern/)

{

693

Chapter 26

If the match is successful, the content of the match, which is contained in the $& variable, is displayed:

print “There was a match: ‘$&’.\n”;

}

If matching is unsuccessful, the statement specified by the else clause is executed:

else

{

print “There was no match.”;

}

When the pattern is [A-Z][a-z]*, it matches an uppercase alphabetic character followed by zero or more lowercase alphabetic characters. In the test string Hello world!, the first matching character sequence is Hello. Matching is greedy, in that it matches as many characters as possible.

When the pattern is [A-E][a-z]*, the initial uppercase alphabetic character must be in the range A through E. Therefore, the H of Hello does not match. However, the E of Ethel does match against [A-E]. The E is followed by lowercase alphabetic characters, so the entire match is Ethel, as shown in Figure 26-25.

Negated character classes specify that a character class matches a character that is not one of those contained between the square brackets. The ^ metacharacter specifies that it is a negated character class if it is the first character after the opening square bracket.

Try It Out

Using a Negated Character Class

1.Type the following code in a text editor:

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

my $myPattern = “[^A-D]\\d{2}”;

my $myTestString = “A99 B23 C34 D45 E55”;

print “The test string is: ‘$myTestString’.\n”; print “The pattern is: ‘$myPattern’.\n”;

if ($myTestString =~ m/$myPattern/)

{

print “There was a match: ‘$&’.\n”;

}

else

{

print “There was no match.”;

}

2.

3.

Save the code as NegatedCharacterClass.pl.

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

694

Regular Expressions in Perl

Figure 26-26

How It Works

The pattern assigned to the $myPattern variable is [^A-D]\d{2}. Remember, it is necessary to double the backslash to ensure that the \d metacharacter is correctly recognized. The pattern [^A-D]\d{2} matches a character that is not A through D, followed by two numeric digits:

my $myPattern = “[^A-D]\\d{2}”;

The test string is assigned to the include an uppercase alphabetic will not match:

$myTestString variable. Notice that the first four character sequences character in the range A through D, which the negated character class

my $myTestString = “A99 B23 C34 D45 E55”;

The test string and pattern are displayed:

print “The test string is: ‘$myTestString’.\n”;

print “The pattern is: ‘$myPattern’.\n”;

The if statement uses a test that determines whether or not there is a match:

if ($myTestString =~ m/$myPattern/)

Because the negated character class [^A-D] won’t match an uppercase character A through D, the first match is E55. That value is, therefore, displayed using the $& variable:

print “There was a match: ‘$&’.\n”;

You saw earlier in this chapter how variable substitution can be used in other settings. Variable substitution can also be used in character classes.

Try It Out

Using Variable Substitution in a Character Class

1.Type the following code in a text editor:

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

my $toBeSubstituted = “A-D”;

my $myPattern = “[$toBeSubstituted]\\d{2}”; my $myTestString = “A99 B23 C34 D45 E55”;

print “The test string is: ‘$myTestString’.\n”; print “The pattern is: ‘$myPattern’.\n”;

if ($myTestString =~ m/$myPattern/)

695