7.3.1 Single-Character Patterns

The simplest and most common pattern-matching character in regular expressions is a single character that matches itself. In other words, putting a letter a in a regular expression requires a corresponding letter a in the string.

The next most common pattern-matching character is the dot " . ". This character matches any single character except newline ( \n ). For example, the pattern /a./ matches any two-letter sequence that starts with a and is not a\n .

A pattern-matching character class is represented by a pair of open and close square brackets and a list of characters between the brackets. One and only one of these characters must be present at the corresponding part of the string for the pattern to match. For example,

/[abcde]/

matches a string containing any one of the first five letters of the lowercase alphabet, while

/[aeiouAEIOU]/

matches any of the five vowels in either lower- or uppercase. If you want to put a right bracket ( ] ) in the list, put a backslash in front of it, or put it as the first character within the list. Ranges of characters (like a through z ) can be abbreviated by showing the end points of the range separated by a dash ( - ); to get a literal dash in the list, precede the dash with a backslash or place it at the end. Here are some other examples:

[0123456789] # match any single digit
[0-9]        # same thing
[0-9\-]      # match 0-9, or minus
[a-z0-9]     # match any single lowercase letter or digit
[a-zA-Z0-9_] # match any single letter, digit, or underscore

There's also a negated character class, which is the same as a character class, but has a leading up arrow (or caret: ^ ) immediately after the left bracket. This character class matches any single character that is not in the list. For example:

[^0-9] # match any single non-digit
[^aeiouAEIOU] # match any single non-vowel
[^\^] # match single character except an up-arrow

For your convenience, some common character classes are predefined, as described in Table 7.1 .

The \d pattern matches one digit . The \w pattern matches one word character , although the pattern is really matching any character that is legal in a Perl variable name. The \s pattern matches one space ( whitespace), defined here as spaces, carriage returns, tabs, line feeds, and form feeds. The uppercase versions match the complements of these classes. Thus, \W matches one character that can't be in an identifier, \S matches one character that is not a whitespace (including letters, punctuation marks, control characters, etc.), and \D matches any single non-digit character.

These abbreviated classes can be used as part of other character classes as well:

[\da-fA-F] # match one hex digit

7.3.2 Grouping Patterns

The true power of regular expressions comes into play when you can say "one or more of these" or "up to five of those." Let's talk about how these cases are handled.

$_ = "fred xxxxxxxxxx barney";
s/x+/boom/;

$_ = "a xxx c xxxxxxxx c xxx d";
/a.*c.*d/;

$_ = "a xxx c xxxxxxxx c xxx d";
/a.*?c.*d/;

$_ = "a xxx ce xxxxxxxx ci xxx d";
/a.*ce.*d/;

/fred(.)barney

\1/;

/fred.barney./;

/a(.)b(.)c\2d\1/;

/a(.*)b\1c/;

7.3.3 Anchoring Patterns

Several special notations anchor a pattern. Normally, when a pattern is matched against the string, the beginning of the pattern is dragged through the string from left to right, matching at the first possible opportunity. Anchors allow you to ensure that parts of the pattern line up with particular parts of the string.

The first pair of anchors requires that a particular part of the match be located either at a word boundary or not at a word boundary. The \b anchor requires a word boundary at the indicated point for the pattern to match. A word boundary is the place between characters that match \w and \W , or between characters matching \w and the beginning or ending of the string. Note that this description has little to do with English words and a lot more to do with C symbols, but that's as close as we get. For example:

/fred\b/;   # matches fred, but not Frederick
/\bmo/;     # matches moe and mole, but not Elmo
/\bFred\b/; # matches Fred but not Frederick or alFred
/\b\+\b/;   # matches "x+y" but not "++" or " + "
/abc\bdef/; # never matches (impossible for a boundary there)

Likewise, \B requires that there not be a word boundary at the indicated point. For example:

/\bFred\B/; # matches "Frederick" but not "Fred Flintstone"

Two more anchors require that a particular part of the pattern be next to an end of the string. The caret ( ^ ) matches the beginning of the string if it is in a place that makes sense to match the beginning of the string. For example, ^a matches an a if, and only if, the a is the first character of the string. However, a^ matches the two characters a and ^ anywhere in the string. In other words, the caret has lost its special meaning. If you need the caret to be a literal caret even at the beginning, put a backslash in front of it.

The $ , like the ^ , anchors the pattern, but to the end of the string, not the beginning. In other words, c$ matches a c only if it occurs at the end of the string.[ 3 ] A dollar sign anywhere else in the pattern is probably going to be interpreted as a scalar value interpretation, so you'll most likely need to backslash it to match a literal dollar sign in the string.

[3] Or just before the newline at the end of the string, for historical simplicity.

Other anchors are supported, including \A, \Z, and lookahead anchors created via (?=...) and (?!...). These anchors are described fully in Chapter 2 of Programming Perl and the perlre documentation.

7.3.4 Precedence

So what happens when we get a|b* together? Is this a or b any number of times, or is it either a single a or any number of b 's?

Well, just as operators have precedence, the grouping and anchoring patterns also have precedence. The precedence of patterns from highest to lowest is given in Table 7.2 .

[4] Some of these symbols are not described in this book. See Programming Perl or perlre for details.

According to the table, * has a higher precedence than | . So /a|b*/ is interpreted as a single a , or any number of b 's.

What if we want the other meaning, as in "any number of a's or b's"? We simply throw in a pair of parentheses. In this case, we enclose the part of the expression that the * operator should apply to inside parentheses, and we are done, as (a|b)* . If you want to clarify the first expression, you can redundantly parenthesize it with a|(b*) .

When you use parentheses to affect precedence they also trigger the memory, as shown earlier in this chapter. That is, this set of parentheses counts when you are figuring out whether something is \2 , \3 , or whatever. If you want to use parentheses without triggering memory, use the form (?:...) instead of (...). This form still allows for multipliers, but doesn't cause you to throw off your counting by using up another $4 or whatever. For example, /(?:Fred|Wilma) Flintstone/ does not store anything into $1; it's just there for grouping.

Here are some other examples of regular expressions, and the effect of parentheses:

abc*             # matches ab, abc, abcc, abccc, abcccc, and so on
(abc)*           # matches "", abc, abcabc, abcabcabc, and so on
^x|y             # matches x at the beginning of line, or y anywhere
^(x|y)           # matches either x or y at the beginning of a line
a|bc|d           # a, or bc, or d
(a|b)(c|d)       # ac, ad, bc, or bd
(song|blue)bird  # songbird or bluebird