|
Although one can already do quite a lot with the literal string regexps above, we've only
scratched the surface of regular expression technology. In this and subsequent sections we will
introduce regexp concepts (and associated metacharacter notations) that will allow a regexp to
not just represent a single character sequence, but a whole class of them.
One such concept is that of a character class. A character class allows a set of
possible characters, rather than just a single character, to match at a particular point in a
regexp. Character classes are denoted by brackets [...], with the set of characters
to be possibly matched inside. Here are some examples:
/cat/; # matches 'cat'
/[bcr]at/; # matches 'bat, 'cat', or 'rat'
/item[0123456789]/; # matches 'item0' or ... or 'item9'
"abc" =~ /[cab]/; # matches 'a'
|
|
In the last statement, even though 'c' is the first character in the class, 'a'
matches because the first character position in the string is the earliest point at which the
regexp can match.
/[yY][eE][sS]/; # match 'yes' in a case-insensitive way
# 'yes', 'Yes', 'YES', etc.
|
|
This regexp displays a common task: perform a case-insensitive match. Perl provides away of
avoiding all those brackets by simply appending an 'i' to the end of the match.
Then /[yY][eE][sS]/; can be rewritten as /yes/i;. The 'i'
stands for case-insensitive and is an example of a modifier of the matching operation. We
will meet other modifiers later in the tutorial.
We saw in the section above that there were ordinary characters, which represented
themselves, and special characters, which needed a backslash \ to represent
themselves. The same is true in a character class, but the sets of ordinary and special
characters inside a character class are different than those outside a character class. The
special characters for a character class are -]\^$. ] is special
because it denotes the end of a character class. $ is special because it denotes a
scalar variable. \ is special because it is used in escape sequences, just like
above. Here is how the special characters ]$\ are handled:
/[\]c]def/; # matches ']def' or 'cdef'
$x = 'bcr';
/[$x]at/; # matches 'bat', 'cat', or 'rat'
/[\$x]at/; # matches '$at' or 'xat'
/[\\$x]at/; # matches '\at', 'bat, 'cat', or 'rat'
|
|
The last two are a little tricky. in [\$x], the backslash protects the dollar
sign, so the character class has two members $ and x. In [\\$x],
the backslash is protected, so $x is treated as a variable and substituted in
double quote fashion.
The special character '-' acts as a range operator within character classes, so
that a contiguous set of characters can be written as a range. With ranges, the unwieldy [0123456789]
and [abc...xyz] become the svelte [0-9] and [a-z]. Some
examples are
/item[0-9]/; # matches 'item0' or ... or 'item9'
/[0-9bx-z]aa/; # matches '0aa', ..., '9aa',
# 'baa', 'xaa', 'yaa', or 'zaa'
/[0-9a-fA-F]/; # matches a hexadecimal digit
/[0-9a-zA-Z_]/; # matches a "word" character,
# like those in a perl variable name
|
|
If '-' is the first or last character in a character class, it is treated as an
ordinary character; [-ab], [ab-] and [a\-b] are all
equivalent.
The special character ^ in the first position of a character class denotes a negated
character class, which matches any character but those in the brackets. Both [...]
and [^...] must match a character, or the match fails. Then
/[^a]at/; # doesn't match 'aat' or 'at', but matches
# all other 'bat', 'cat, '0at', '%at', etc.
/[^0-9]/; # matches a non-numeric character
/[a^]at/; # matches 'aat' or '^at'; here '^' is ordinary
|
|
Now, even [0-9] can be a bother the write multiple times, so in the interest of
saving keystrokes and making regexps more readable, Perl has several abbreviations for common
character classes:
- \d is a digit and represents [0-9]
- \s is a whitespace character and represents [\ \t\r\n\f]
- \w is a word character (alphanumeric or _) and represents [0-9a-zA-Z_]
- \D is a negated \d; it represents any character but a digit [^0-9]
- \S is a negated \s; it represents any non-whitespace character [^\s]
- \W is a negated \w; it represents any non-word character [^\w]
- The period '.' matches any character but "\n"
The \d\s\w\D\S\W abbreviations can be used both inside and outside of character
classes. Here are some in use:
/\d\d:\d\d:\d\d/; # matches a hh:mm:ss time format
/[\d\s]/; # matches any digit or whitespace character
/\w\W\w/; # matches a word char, followed by a
# non-word char, followed by a word char
/..rt/; # matches any two chars, followed by 'rt'
/end\./; # matches 'end.'
/end[.]/; # same thing, matches 'end.'
|
|
Because a period is a metacharacter, it needs to be escaped to match as an ordinary period.
Because, for example, \d and \w are sets of characters, it is
incorrect to think of [^\d\w] as [\D\W]; in fact [^\d\w]
is the same as [^\w], which is the same as [\W]. Think DeMorgan's
laws.
An anchor useful in basic regexps is the word anchor \b. This
matches a boundary between a word character and a non-word character \w\W or \W\w:
$x = "Housecat catenates house and cat";
$x =~ /cat/; # matches cat in 'housecat'
$x =~ /\bcat/; # matches cat in 'catenates'
$x =~ /cat\b/; # matches cat in 'housecat'
$x =~ /\bcat\b/; # matches 'cat' at end of string
|
|
Note in the last example, the end of the string is considered a word boundary.
You might wonder why '.' matches everything but "\n" -
why not every character? The reason is that often one is matching against lines and would like
to ignore the newline characters. For instance, while the string "\n"
represents one line, we would like to think of as empty. Then
"" =~ /^$/; # matches
"\n" =~ /^$/; # matches, "\n" is ignored
"" =~ /./; # doesn't match; it needs a char
"" =~ /^.$/; # doesn't match; it needs a char
"\n" =~ /^.$/; # doesn't match; it needs a char other than "\n"
"a" =~ /^.$/; # matches
"a\n" =~ /^.$/; # matches, ignores the "\n"
|
|
This behavior is convenient, because we usually want to ignore newlines when we count and
match characters in a line. Sometimes, however, we want to keep track of newlines. We might even
want ^ and $ to anchor at the beginning and end of lines within the
string, rather than just the beginning and end of the string. Perl allows us to choose between
ignoring and paying attention to newlines by using the //s and //m
modifiers. //s and //m stand for single line and multi-line and they
determine whether a string is to be treated as one continuous string, or as a set of lines. The
two modifiers affect two aspects of how the regexp is interpreted: 1) how the '.'
character class is defined, and 2) where the anchors ^ and $ are able
to match. Here are the four possible combinations:
- no modifiers (//): Default behavior.
'.' matches any character except "\n".
^ matches only at the beginning of the string and $ matches only
at the end or before a newline at the end.
- s modifier (//s): Treat string as a single long line.
'.' matches any
character, even "\n". ^ matches only at the beginning of
the string and $ matches only at the end or before a newline at the end.
- m modifier (//m): Treat string as a set of multiple lines.
'.' matches any
character except "\n". ^ and $ are able to
match at the start or end of any line within the string.
- both s and m modifiers (//sm): Treat string as a single long line, but detect multiple
lines.
'.' matches any character, even "\n". ^
and $, however, are able to match at the start or end of any line within
the string.
Here are examples of //s and //m in action:
$x = "There once was a girl\nWho programmed in Perl\n";
$x =~ /^Who/; # doesn't match, "Who" not at start of string
$x =~ /^Who/s; # doesn't match, "Who" not at start of string
$x =~ /^Who/m; # matches, "Who" at start of second line
$x =~ /^Who/sm; # matches, "Who" at start of second line
$x =~ /girl.Who/; # doesn't match, "." doesn't match "\n"
$x =~ /girl.Who/s; # matches, "." matches "\n"
$x =~ /girl.Who/m; # doesn't match, "." doesn't match "\n"
$x =~ /girl.Who/sm; # matches, "." matches "\n"
|
|
Most of the time, the default behavior is what is want, but //s and //m
are occasionally very useful. If //m is being used, the start of the string can
still be matched with \A and the end of string can still be matched with the
anchors \Z (matches both the end and the newline before, like $), and \z
(matches only the end):
$x =~ /^Who/m; # matches, "Who" at start of second line
$x =~ /\AWho/m; # doesn't match, "Who" is not at start of string
$x =~ /girl$/m; # matches, "girl" at end of first line
$x =~ /girl\Z/m; # doesn't match, "girl" is not at end of string
$x =~ /Perl\Z/m; # matches, "Perl" is at newline before end
$x =~ /Perl\z/m; # doesn't match, "Perl" is not at end of string
|
|
We now know how to create choices among classes of characters in a regexp. What about choices
among words or character strings? Such choices are described in the next section.
|
|
