PERLRETUT(1) Perl Programmers Reference Guide PERLRETUT(1)
NAME
perlretut - Perl regular expressions tutorial
DESCRIPTION
This page provides a basic tutorial on understanding, creating and
using regular expressions in(1,8) Perl. It serves as a complement to the
reference page on regular expressions perlre. Regular expressions are
an integral part of the "m//", "s///", "qr//" and "split(1,n)" operators and
so this tutorial also overlaps with "Regexp Quote-Like Operators" in(1,8)
perlop and "split(1,n)" in(1,8) perlfunc.
Perl is widely renowned for excellence in(1,8) text processing, and regular
expressions are one of the big factors behind this fame. Perl regular
expressions display an efficiency and flexibility unknown in(1,8) most other
computer languages. Mastering even the basics of regular expressions
will allow you to manipulate text with surprising ease.
What is a regular expression? A regular expression is simply a string(3,n)
that describes a pattern. Patterns are in(1,8) common use these days; exam-
ples are the patterns typed into a search engine to find web pages and
the patterns used to list files in(1,8) a directory, e.g., "ls *.txt" or
"dir *.*". In Perl, the patterns described by regular expressions are
used to search strings, extract desired parts of strings, and to do
search and replace operations.
Regular expressions have the undeserved reputation of being abstract
and difficult to understand. Regular expressions are constructed using
simple concepts like conditionals and loops and are no more difficult
to understand than the corresponding "if(3,n)" conditionals and "while"
loops in(1,8) the Perl language itself. In fact, the main challenge in(1,8)
learning regular expressions is just getting used to the terse notation
used to express these concepts.
This tutorial flattens the learning curve by discussing regular expres-
sion concepts, along with their notation, one at a time(1,2,n) and with many
examples. The first part of the tutorial will progress from the sim-
plest word searches to the basic regular expression concepts. If you
master(5,8) the first part, you will have all the tools needed to solve
about 98% of your needs. The second part of the tutorial is for those
comfortable with the basics and hungry for more power tools. It dis-
cusses the more advanced regular expression operators and introduces
the latest cutting edge innovations in(1,8) 5.6.0.
A note: to save time(1,2,n), 'regular expression' is often abbreviated as reg-
exp or regex. Regexp is a more natural abbreviation than regex(3,7), but is
harder to pronounce. The Perl pod documentation is evenly split(1,n) on
regexp(3,n) vs regex(3,7); in(1,8) Perl, there is more than one way to abbreviate it.
We'll use regexp(3,n) in(1,8) this tutorial.
Part 1: The basics
Simple word matching
The simplest regexp(3,n) is simply a word, or more generally, a string(3,n) of
characters. A regexp(3,n) consisting of a word matches any string(3,n) that con-
tains that word:
"Hello World" =~ /World/; # matches
What is this perl statement all about? "Hello World" is a simple double
quoted string. "World" is the regular expression and the "//" enclos-
ing "/World/" tells perl to search a string(3,n) for a match. The operator
"=~" associates the string(3,n) with the regexp(3,n) match and produces a true
value if(3,n) the regexp(3,n) matched, or false if(3,n) the regexp(3,n) did not match. In
our case, "World" matches the second word in(1,8) "Hello World", so the
expression is true. Expressions like this are useful in(1,8) conditionals:
if(3,n) ("Hello World" =~ /World/) {
print "It matches\n";
}
else {
print "It doesn't match\n";
}
There are useful variations on this theme. The sense of the match can
be reversed by using "!~" operator:
if(3,n) ("Hello World" !~ /World/) {
print "It doesn't match\n";
}
else {
print "It matches\n";
}
The literal string(3,n) in(1,8) the regexp(3,n) can be replaced by a variable:
$greeting = "World";
if(3,n) ("Hello World" =~ /$greeting/) {
print "It matches\n";
}
else {
print "It doesn't match\n";
}
If you're matching against the special default variable $_, the "$_ =~"
part can be omitted:
$_ = "Hello World";
if(3,n) (/World/) {
print "It matches\n";
}
else {
print "It doesn't match\n";
}
And finally, the "//" default delimiters for a match can be changed to
arbitrary delimiters by putting an 'm' out front:
"Hello World" =~ m!World!; # matches, delimited by '!'
"Hello World" =~ m{World}; # matches, note the matching '{}'
"/usr/bin/perl" =~ m"/perl"; # matches after '/usr/bin',
# '/' becomes an ordinary char
"/World/", "m!World!", and "m{World}" all represent the same thing.
When, e.g., "" is used as a delimiter, the forward slash '/' becomes an
ordinary character and can be used in(1,8) a regexp(3,n) without trouble.
Let's consider how different regexps would match "Hello World":
"Hello World" =~ /world/; # doesn't match
"Hello World" =~ /o W/; # matches
"Hello World" =~ /oW/; # doesn't match
"Hello World" =~ /World /; # doesn't match
The first regexp(3,n) "world" doesn't match because regexps are case-sensi-
tive. The second regexp(3,n) matches because the substring 'o W' occurs in(1,8)
the string(3,n) "Hello World" . The space character ' ' is treated like any
other character in(1,8) a regexp(3,n) and is needed to match in(1,8) this case. The
lack of a space character is the reason the third regexp(3,n) 'oW' doesn't
match. The fourth regexp(3,n) 'World ' doesn't match because there is a
space at the end of the regexp(3,n), but not at the end of the string. The
lesson here is that regexps must match a part of the string(3,n) exactly in(1,8)
order for the statement to be true.
If a regexp(3,n) matches in(1,8) more than one place in(1,8) the string(3,n), perl will
always match at the earliest possible point in(1,8) the string:
"Hello World" =~ /o/; # matches 'o' in(1,8) 'Hello'
"That hat is red" =~ /hat/; # matches 'hat' in(1,8) 'That'
With respect to character matching, there are a few more points you
need to know about. First of all, not all characters can be used 'as
is' in(1,8) a match. Some characters, called metacharacters, are reserved
for use in(1,8) regexp(3,n) notation. The metacharacters are
{}[]()^$.|*+?\
The significance of each of these will be explained in(1,8) the rest of the
tutorial, but for now, it is important only to know that a metacharac-
ter can be matched by putting a backslash before it:
"2+2=4" =~ /2+2/; # doesn't match, + is a metacharacter
"2+2=4" =~ /2\+2/; # matches, \+ is treated like an ordinary +
"The interval is [0,1)." =~ /[0,1)./ # is a syntax error(8,n)!
"The interval is [0,1)." =~ /\[0,1\)\./ # matches
"/usr/bin/perl" =~ /\/usr\/bin\/perl/; # matches
In the last regexp(3,n), the forward slash '/' is also backslashed, because
it is used to delimit the regexp. This can lead to LTS (leaning tooth-
pick syndrome), however, and it is often more readable to change delim-
iters.
"/usr/bin/perl" =~ m!/usr/bin/perl!; # easier to read(2,n,1 builtins)
The backslash character '\' is a metacharacter itself and needs to be
backslashed:
'C:\WIN32' =~ /C:\\WIN/; # matches
In addition to the metacharacters, there are some ASCII characters
which don't have printable character equivalents and are instead repre-
sented by escape sequences. Common examples are "\t" for a tab, "\n"
for a newline, "\r" for a carriage return and "\a" for a bell. If your
string(3,n) is better thought of as a sequence of arbitrary bytes, the octal
escape sequence, e.g., "\033", or hexadecimal escape sequence, e.g.,
"\x1B" may be a more natural representation for your bytes. Here are
some examples of escapes:
"1000\t2000" =~ m(0\t2) # matches
"1000\n2000" =~ /0\n20/ # matches
"1000\t2000" =~ /\000\t2/ # doesn't match, "0" ne "\000"
"cat" =~ /\143\x61\x74/ # matches, but a weird way to spell cat
If you've been around Perl a while, all this talk of escape sequences
may seem familiar. Similar escape sequences are used in(1,8) double-quoted
strings and in(1,8) fact the regexps in(1,8) Perl are mostly treated as double-
quoted strings. This means that variables can be used in(1,8) regexps as
well. Just like double-quoted strings, the values of the variables in(1,8)
the regexp(3,n) will be substituted in(1,8) before the regexp(3,n) is evaluated for
matching purposes. So we have:
$foo = 'house';
'housecat' =~ /$foo/; # matches
'cathouse' =~ /cat$foo/; # matches
'housecat' =~ /${foo}cat/; # matches
So far, so good. With the knowledge above you can already perform
searches with just about any literal string(3,n) regexp(3,n) you can dream up.
Here is a very simple emulation of the Unix grep program:
% cat > simple_grep
#!/usr/bin/perl
$regexp(3,n) = shift;
while (<>) {
print if(3,n) /$regexp(3,n)/;
}
^D
% chmod(1,2) +x simple_grep
% simple_grep abba /usr/dict/words
Babbage
cabbage
cabbages
sabbath
Sabbathize
Sabbathizes
sabbatical
scabbard
scabbards
This program is easy to understand. "#!/usr/bin/perl" is the standard
way to invoke a perl program from the shell. "$regexp(3,n) = shift;" saves
the first command line argument as the regexp(3,n) to be used, leaving the
rest of the command line arguments to be treated as files.
"while (<>)" loops over all the lines in(1,8) all the files. For each
line, "print if(3,n) /$regexp(3,n)/;" prints the line if(3,n) the regexp(3,n) matches the
line. In this line, both "print" and "/$regexp(3,n)/" use the default vari-
able $_ implicitly.
With all of the regexps above, if(3,n) the regexp(3,n) matched anywhere in(1,8) the
string(3,n), it was considered a match. Sometimes, however, we'd like to
specify where in(1,8) the string(3,n) the regexp(3,n) should try to match. To do
this, we would use the anchor metacharacters "^" and "$". The anchor
"^" means match at the beginning of the string(3,n) and the anchor "$" means
match at the end of the string(3,n), or before a newline at the end of the
string. Here is how they are used:
"housekeeper" =~ /keeper/; # matches
"housekeeper" =~ /^keeper/; # doesn't match
"housekeeper" =~ /keeper$/; # matches
"housekeeper\n" =~ /keeper$/; # matches
The second regexp(3,n) doesn't match because "^" constrains "keeper" to
match only at the beginning of the string(3,n), but "housekeeper" has keeper
starting in(1,8) the middle. The third regexp(3,n) does match, since the "$"
constrains "keeper" to match only at the end of the string.
When both "^" and "$" are used at the same time(1,2,n), the regexp(3,n) has to
match both the beginning and the end of the string(3,n), i.e., the regexp(3,n)
matches the whole string. Consider
"keeper" =~ /^keep$/; # doesn't match
"keeper" =~ /^keeper$/; # matches
"" =~ /^$/; # ^$ matches an empty string(3,n)
The first regexp(3,n) doesn't match because the string(3,n) has more to it than
"keep". Since the second regexp(3,n) is exactly the string(3,n), it matches.
Using both "^" and "$" in(1,8) a regexp(3,n) forces the complete string(3,n) to match,
so it gives you complete control over which strings match and which
don't. Suppose you are looking for a fellow named(5,8) bert, off in(1,8) a
string(3,n) by himself:
"dogbert" =~ /bert/; # matches, but not what you want
"dilbert" =~ /^bert/; # doesn't match, but ..
"bertram" =~ /^bert/; # matches, so still not good enough
"bertram" =~ /^bert$/; # doesn't match, good
"dilbert" =~ /^bert$/; # doesn't match, good
"bert" =~ /^bert$/; # matches, perfect
Of course, in(1,8) the case of a literal string(3,n), one could just as easily
use the string(3,n) equivalence "$string(3,n) eq 'bert'" and it would be more
efficient. The "^...$" regexp(3,n) really becomes useful when we add in(1,8)
the more powerful regexp(3,n) tools below.
Using character classes
Although one can already do quite a lot with the literal string(3,n) regexps
above, we've only scratched the surface of regular expression technol-
ogy. In this and subsequent sections we will introduce regexp(3,n) concepts
(and associated metacharacter notations) that will allow a regexp(3,n) 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(7,n,1 builtins) of possible characters, rather than just a single charac-
ter, to match at a particular point in(1,8) a regexp. Character classes are
denoted by brackets "[...]", with the set(7,n,1 builtins) 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(1,8) the
class, 'a' matches because the first character position in(1,8) the string(3,n)
is the earliest point at which the regexp(3,n) can match.
/[yY][eE][sS]/; # match 'yes' in(1,8) a case-insensitive way
# 'yes', 'Yes', 'YES', etc.
This regexp(3,n) 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 rewrit-
ten as "/yes/i;". The 'i' stands for case-insensitive and is an exam-
ple of a modifier of the matching operation. We will meet other modi-
fiers later in(1,8) the tutorial.
We saw in(1,8) the section above that there were ordinary characters, which
represented themselves, and special characters, which needed a back-
slash "\" to represent themselves. The same is true in(1,8) a character
class, but the sets of ordinary and special characters inside a charac-
ter class are different than those outside a character class. The spe-
cial 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(1,8) 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(1,8) "[\$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(1,8) double quote fashion.
The special character '-' acts as a range operator within character
classes, so that a contiguous set(7,n,1 builtins) 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(1,8) a perl variable name
If '-' is the first or last character in(1,8) a character class, it is
treated as an ordinary character; "[-ab]", "[ab-]" and "[a\-b]" are all
equivalent.
The special character "^" in(1,8) the first position of a character class
denotes a negated character class, which matches any character but
those in(1,8) the brackets. Both "[...]" and "[^...]" must match a charac-
ter, 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(1,2) multiple times, so in(1,8) 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(1,8) use:
/\d\d:\d\d:\d\d/; # matches a hh:mm:ss time(1,2,n) 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(1,8) fact
"[^\d\w]" is the same as "[^\w]", which is the same as "[\W]". Think
DeMorgan's laws.
An anchor useful in(1,8) 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(1,8) 'housecat'
$x =~ /\bcat/; # matches cat in(1,8) 'catenates'
$x =~ /cat\b/; # matches cat in(1,8) 'housecat'
$x =~ /\bcat\b/; # matches 'cat' at end of string(3,n)
Note in(1,8) the last example, the end of the string(3,n) 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(3,n) "\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(1,8) 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(3,n), 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(3,n) is to be treated as one con-
tinuous string(3,n), or as a set(7,n,1 builtins) of lines. The two modifiers affect two
aspects of how the regexp(3,n) 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(3,n) and
"$" matches only at the end or before a newline at the end.
s modifier (//s): Treat string(3,n) as a single long line. '.' matches
any character, even "\n". "^" matches only at the beginning of the
string(3,n) and "$" matches only at the end or before a newline at the
end.
m modifier (//m): Treat string(3,n) as a set(7,n,1 builtins) 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(3,n) 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(1,8) action:
$x = "There once was a girl\nWho programmed in(1,8) Perl\n";
$x =~ /^Who/; # doesn't match, "Who" not at start of string(3,n)
$x =~ /^Who/s; # doesn't match, "Who" not at start of string(3,n)
$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(1,2,n), 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(3,n) can still be matched with "\A" and the end of string(3,n) 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(3,n)
$x =~ /girl$/m; # matches, "girl" at end of first line
$x =~ /girl\Z/m; # doesn't match, "girl" is not at end of string(3,n)
$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(3,n)
We now know how to create choices among classes of characters in(1,8) a reg-
exp. What about choices among words or character strings? Such choices
are described in(1,8) the next section.
Matching this or that
Sometimes we would like to our regexp(3,n) to be able to match different
possible words or character strings. This is accomplished by using the
alternation metacharacter "|". To match "dog" or "cat", we form the
regexp(3,n) "dog|cat". As before, perl will try to match the regexp(3,n) at the
earliest possible point in(1,8) the string. At each character position,
perl will first try to match the first alternative, "dog". If "dog"
doesn't match, perl will then try the next alternative, "cat". If
"cat" doesn't match either, then the match fails and perl moves to the
next position in(1,8) the string. Some examples:
"cats and dogs" =~ /cat|dog|bird/; # matches "cat"
"cats and dogs" =~ /dog|cat|bird/; # matches "cat"
Even though "dog" is the first alternative in(1,8) the second regexp(3,n), "cat"
is able to match earlier in(1,8) the string.
"cats" =~ /c|ca|cat|cats/; # matches "c"
"cats" =~ /cats|cat|ca|c/; # matches "cats"
Here, all the alternatives match at the first string(3,n) position, so the
first alternative is the one that matches. If some of the alternatives
are truncations of the others, put the longest ones first to give them
a chance to match.
"cab" =~ /a|b|c/ # matches "c"
# /a|b|c/ == /[abc]/
The last example points out that character classes are like alterna-
tions of characters. At a given character position, the first alterna-
tive that allows the regexp(3,n) match to succeed will be the one that
matches.
Grouping things and hierarchical matching
Alternation allows a regexp(3,n) to choose among alternatives, but by itself
it unsatisfying. The reason is that each alternative is a whole reg-
exp, but sometime we want alternatives for just part of a regexp. For
instance, suppose we want to search for housecats or housekeepers. The
regexp(3,n) "housecat|housekeeper" fits the bill, but is inefficient because
we had to type "house" twice. It would be nice(1,2) to have parts of the
regexp(3,n) be constant, like "house", and some parts have alternatives,
like "cat|keeper".
The grouping metacharacters "()" solve this problem. Grouping allows
parts of a regexp(3,n) to be treated as a single unit. Parts of a regexp(3,n)
are grouped by enclosing them in(1,8) parentheses. Thus we could solve the
"housecat|housekeeper" by forming the regexp(3,n) as "house(cat|keeper)".
The regexp(3,n) "house(cat|keeper)" means match "house" followed by either
"cat" or "keeper". Some more examples are
/(a|b)b/; # matches 'ab' or 'bb'
/(ac|b)b/; # matches 'acb' or 'bb'
/(^a|b)c/; # matches 'ac' at start of string(3,n) or 'bc' anywhere
/(a|[bc])d/; # matches 'ad', 'bd', or 'cd'
/house(cat|)/; # matches either 'housecat' or 'house'
/house(cat(s|)|)/; # matches either 'housecats' or 'housecat' or
# 'house'. Note groups can be nested.
/(19|20|)\d\d/; # match years 19xx, 20xx, or the Y2K problem, xx
"20" =~ /(19|20|)\d\d/; # matches the null alternative '()\d\d',
# because '20\d\d' can't match
Alternations behave the same way in(1,8) groups as out of them: at a given
string(3,n) position, the leftmost alternative that allows the regexp(3,n) to
match is taken. So in(1,8) the last example at the first string(3,n) position,
"20" matches the second alternative, but there is nothing left over to
match the next two digits "\d\d". So perl moves on to the next alter-
native, which is the null alternative and that works, since "20" is two
digits.
The process of trying one alternative, seeing if(3,n) it matches, and moving
on to the next alternative if(3,n) it doesn't, is called backtracking. The
term(5,7) 'backtracking' comes from the idea that matching a regexp(3,n) is like
a walk in(1,8) the woods. Successfully matching a regexp(3,n) is like arriving
at a destination. There are many possible trailheads, one for each
string(3,n) position, and each one is tried in(1,8) order, left to right. From
each trailhead there may be many paths, some of which get you there,
and some which are dead ends. When you walk along a trail and hit a
dead end, you have to backtrack along the trail to an earlier point to
try another trail. If you hit your destination, you stop immediately
and forget about trying all the other trails. You are persistent, and
only if(3,n) you have tried all the trails from all the trailheads and not
arrived at your destination, do you declare failure. To be concrete,
here is a step-by-step analysis of what perl does when it tries to
match the regexp(3,n)
"abcde" =~ /(abd|abc)(df|d|de)/;
0 Start with the first letter in(1,8) the string(3,n) 'a'.
1 Try the first alternative in(1,8) the first group 'abd'.
2 Match 'a' followed by 'b'. So far so good.
3 'd' in(1,8) the regexp(3,n) doesn't match 'c' in(1,8) the string(3,n) - a dead end. So
backtrack two characters and pick the second alternative in(1,8) the
first group 'abc'.
4 Match 'a' followed by 'b' followed by 'c'. We are on a roll and
have satisfied the first group. Set $1 to 'abc'.
5 Move on to the second group and pick the first alternative 'df'.
6 Match the 'd'.
7 'f' in(1,8) the regexp(3,n) doesn't match 'e' in(1,8) the string(3,n), so a dead end.
Backtrack one character and pick the second alternative in(1,8) the sec-
ond group 'd'.
8 'd' matches. The second grouping is satisfied, so set(7,n,1 builtins) $2 to 'd'.
9 We are at the end of the regexp(3,n), so we are done! We have matched
'abcd' out of the string(3,n) "abcde".
There are a couple of things to note about this analysis. First, the
third alternative in(1,8) the second group 'de' also allows a match, but we
stopped before we got to it - at a given character position, leftmost
wins. Second, we were able to get a match at the first character posi-
tion of the string(3,n) 'a'. If there were no matches at the first posi-
tion, perl would move(3x,7,3x curs_move) to the second character position 'b' and attempt
the match all over again. Only when all possible paths at all possible
character positions have been exhausted does perl give up and declare
"$string(3,n) =~ /(abd|abc)(df|d|de)/;" to be false.
Even with all this work, regexp(3,n) matching happens remarkably fast. To
speed things up, during compilation stage, perl compiles the regexp(3,n)
into a compact sequence of opcodes that can often fit inside a proces-
sor cache. When the code is executed, these opcodes can then run at
full throttle and search very quickly.
Extracting matches
The grouping metacharacters "()" also serve another completely differ-
ent function: they allow the extraction of the parts of a string(3,n) that
matched. This is very useful to find out what matched and for text
processing in(1,8) general. For each grouping, the part that matched inside
goes into the special variables $1, $2, etc. They can be used just as
ordinary variables:
# extract hours, minutes, seconds
if(3,n) ($time(1,2,n) =~ /(\d\d):(\d\d):(\d\d)/) { # match hh:mm:ss format
$hours = $1;
$minutes = $2;
$seconds = $3;
}
Now, we know that in(1,8) scalar context, "$time(1,2,n) =~ /(\d\d):(\d\d):(\d\d)/"
returns a true or false value. In list context, however, it returns
the list of matched values "($1,$2,$3)". So we could write(1,2) the code
more compactly as
# extract hours, minutes, seconds
($hours, $minutes, $second) = ($time(1,2,n) =~ /(\d\d):(\d\d):(\d\d)/);
If the groupings in(1,8) a regexp(3,n) are nested, $1 gets(3,n) the group with the
leftmost opening parenthesis, $2 the next opening parenthesis, etc.
For example, here is a complex regexp(3,n) and the matching variables indi-
cated below it:
/(ab(cd|ef)((gi)|j))/;
1 2 34
so that if(3,n) the regexp(3,n) matched, e.g., $2 would contain 'cd' or 'ef'. For
convenience, perl sets $+ to the string(3,n) held by the highest numbered
$1, $2, ... that got assigned (and, somewhat related, $^N to the value
of the $1, $2, ... most-recently assigned; i.e. the $1, $2, ... associ-
ated with the rightmost closing parenthesis used in(1,8) the match).
Closely associated with the matching variables $1, $2, ... are the
backreferences "\1", "\2", ... . Backreferences are simply matching
variables that can be used inside a regexp. This is a really nice(1,2) fea-
ture - what matches later in(1,8) a regexp(3,n) can depend on what matched ear-
lier in(1,8) the regexp. Suppose we wanted to look(1,8,3 Search::Dict) for doubled words in(1,8)
text, like 'the the'. The following regexp(3,n) finds all 3-letter doubles
with a space in(1,8) between:
/(\w\w\w)\s\1/;
The grouping assigns a value to \1, so that the same 3 letter sequence
is used for both parts. Here are some words with repeated parts:
% simple_grep '^(\w\w\w\w|\w\w\w|\w\w|\w)\1$' /usr/dict/words
beriberi
booboo
coco
mama
murmur
papa
The regexp(3,n) has a single grouping which considers 4-letter combinations,
then 3-letter combinations, etc. and uses "\1" to look(1,8,3 Search::Dict) for a repeat.
Although $1 and "\1" represent the same thing, care should be taken to
use matched variables $1, $2, ... only outside a regexp(3,n) and backrefer-
ences "\1", "\2", ... only inside a regexp(3,n); not doing so may lead to
surprising and/or undefined results.
In addition to what was matched, Perl 5.6.0 also provides the positions
of what was matched with the "@-" and "@+" arrays. "$-[0]" is the posi-
tion of the start of the entire match and $+[0] is the position of the
end. Similarly, "$-[n]" is the position of the start of the $n match
and $+[n] is the position of the end. If $n is undefined, so are
"$-[n]" and $+[n]. Then this code
$x = "Mmm...donut, thought Homer";
$x =~ /^(Mmm|Yech)\.\.\.(donut|peas)/; # matches
foreach $expr(1,3,n) (1..$#-) {
print "Match $expr: '${$expr(1,3,n)}' at position ($-[$expr(1,3,n)],$+[$expr(1,3,n)])\n";
}
prints
Match 1: 'Mmm' at position (0,3)
Match 2: 'donut' at position (6,11)
Even if(3,n) there are no groupings in(1,8) a regexp(3,n), it is still possible to
find out what exactly matched in(1,8) a string. If you use them, perl will
set(7,n,1 builtins) $` to the part of the string(3,n) before the match, will set(7,n,1 builtins) $& to the
part of the string(3,n) that matched, and will set(7,n,1 builtins) $' to the part of the
string(3,n) after the match. An example:
$x = "the cat caught the mouse";
$x =~ /cat/; # $` = 'the ', $& = 'cat', $' = ' caught the mouse'
$x =~ /the/; # $` = '', $& = 'the', $' = ' cat caught the mouse'
In the second match, "$` = ''" because the regexp(3,n) matched at the first
character position in(1,8) the string(3,n) and stopped, it never saw the second
'the'. It is important to note that using $` and $' slows down regexp(3,n)
matching quite a bit, and $& slows it down to a lesser extent,
because if(3,n) they are used in(1,8) one regexp(3,n) in(1,8) a program, they are generated
for <all> regexps in(1,8) the program. So if(3,n) raw(3x,7,8,3x cbreak) performance is a goal of
your application, they should be avoided. If you need them, use "@-"
and "@+" instead:
$` is the same as substr( $x, 0, $-[0] )
$& is the same as substr( $x, $-[0], $+[0]-$-[0] )
$' is the same as substr( $x, $+[0] )
Matching repetitions
The examples in(1,8) the previous section display an annoying weakness. We
were only matching 3-letter words, or syllables of 4 letters or less.
We'd like to be able to match words or syllables of any length, without
writing out tedious alternatives like "\w\w\w\w|\w\w\w|\w\w|\w".
This is exactly the problem the quantifier metacharacters "?", "*",
"+", and "{}" were created for. They allow us to determine the number
of repeats of a portion of a regexp(3,n) we consider to be a match. Quanti-
fiers are put immediately after the character, character class, or
grouping that we want to specify. They have the following meanings:
"a?" = match 'a' 1 or 0 times
"a*" = match 'a' 0 or more times, i.e., any number of times
"a+" = match 'a' 1 or more times, i.e., at least once
"a{n,m}" = match at least "n" times, but not more than "m" times.
"a{n,}" = match at least "n" or more times
"a{n}" = match exactly "n" times
Here are some examples:
/[a-z]+\s+\d*/; # match a lowercase word, at least some space, and
# any number of digits
/(\w+)\s+\1/; # match doubled words of arbitrary length
/y(es)?/i; # matches 'y', 'Y', or a case-insensitive 'yes'
$year =~ /\d{2,4}/; # make sure year is at least 2 but not more
# than 4 digits
$year =~ /\d{4}|\d{2}/; # better match; throw out 3 digit dates
$year =~ /\d{2}(\d{2})?/; # same thing written differently. However,
# this produces $1 and the other does not.
% simple_grep '^(\w+)\1$' /usr/dict/words # isn't this easier?
beriberi
booboo
coco
mama
murmur
papa
For all of these quantifiers, perl will try to match as much of the
string(3,n) as possible, while still allowing the regexp(3,n) to succeed. Thus
with "/a?.../", perl will first try to match the regexp(3,n) with the "a"
present; if(3,n) that fails, perl will try to match the regexp(3,n) without the
"a" present. For the quantifier "*", we get the following:
$x = "the cat in(1,8) the hat";
$x =~ /^(.*)(cat)(.*)$/; # matches,
# $1 = 'the '
# $2 = 'cat'
# $3 = ' in(1,8) the hat'
Which is what we might expect, the match finds the only "cat" in(1,8) the
string(3,n) and locks onto it. Consider, however, this regexp:
$x =~ /^(.*)(at)(.*)$/; # matches,
# $1 = 'the cat in(1,8) the h'
# $2 = 'at'
# $3 = '' (0 matches)
One might initially guess that perl would find the "at" in(1,8) "cat" and
stop there, but that wouldn't give the longest possible string(3,n) to the
first quantifier ".*". Instead, the first quantifier ".*" grabs as
much of the string(3,n) as possible while still having the regexp(3,n) match. In
this example, that means having the "at" sequence with the final "at"
in(1,8) the string. The other important principle illustrated here is that
when there are two or more elements in(1,8) a regexp(3,n), the leftmost quanti-
fier, if(3,n) there is one, gets(3,n) to grab as much the string(3,n) as possible,
leaving the rest of the regexp(3,n) to fight over scraps. Thus in(1,8) our exam-
ple, the first quantifier ".*" grabs most of the string(3,n), while the sec-
ond quantifier ".*" gets(3,n) the empty string. Quantifiers that grab as
much of the string(3,n) as possible are called maximal match or greedy quan-
tifiers.
When a regexp(3,n) can match a string(3,n) in(1,8) several different ways, we can use
the principles above to predict which way the regexp(3,n) will match:
Principle 0: Taken as a whole, any regexp(3,n) will be matched at the
earliest possible position in(1,8) the string.
Principle 1: In an alternation "a|b|c...", the leftmost alternative
that allows a match for the whole regexp(3,n) will be the one used.
Principle 2: The maximal matching quantifiers "?", "*", "+" and
"{n,m}" will in(1,8) general match as much of the string(3,n) as possible
while still allowing the whole regexp(3,n) to match.
Principle 3: If there are two or more elements in(1,8) a regexp(3,n), the
leftmost greedy quantifier, if(3,n) any, will match as much of the
string(3,n) as possible while still allowing the whole regexp(3,n) to match.
The next leftmost greedy quantifier, if(3,n) any, will try to match as
much of the string(3,n) remaining available to it as possible, while
still allowing the whole regexp(3,n) to match. And so on, until all the
regexp(3,n) elements are satisfied.
As we have seen above, Principle 0 overrides the others - the regexp(3,n)
will be matched as early as possible, with the other principles deter-
mining how the regexp(3,n) matches at that earliest character position.
Here is an example of these principles in(1,8) action:
$x = "The programming republic of Perl";
$x =~ /^(.+)(e|r)(.*)$/; # matches,
# $1 = 'The programming republic of Pe'
# $2 = 'r'
# $3 = 'l'
This regexp(3,n) matches at the earliest string(3,n) position, 'T'. One might
think that "e", being leftmost in(1,8) the alternation, would be matched,
but "r" produces the longest string(3,n) in(1,8) the first quantifier.
$x =~ /(m{1,2})(.*)$/; # matches,
# $1 = 'mm'
# $2 = 'ing republic of Perl'
Here, The earliest possible match is at the first 'm' in(1,8) "programming".
"m{1,2}" is the first quantifier, so it gets(3,n) to match a maximal "mm".
$x =~ /.*(m{1,2})(.*)$/; # matches,
# $1 = 'm'
# $2 = 'ing republic of Perl'
Here, the regexp(3,n) matches at the start of the string. The first quanti-
fier ".*" grabs as much as possible, leaving just a single 'm' for the
second quantifier "m{1,2}".
$x =~ /(.?)(m{1,2})(.*)$/; # matches,
# $1 = 'a'
# $2 = 'mm'
# $3 = 'ing republic of Perl'
Here, ".?" eats its maximal one character at the earliest possible
position in(1,8) the string(3,n), 'a' in(1,8) "programming", leaving "m{1,2}" the
opportunity to match both "m"'s. Finally,
"aXXXb" =~ /(X*)/; # matches with $1 = ''
because it can match zero copies of 'X' at the beginning of the string.
If you definitely want to match at least one 'X', use "X+", not "X*".
Sometimes greed is not good. At times, we would like quantifiers to
match a minimal piece of string(3,n), rather than a maximal piece. For this
purpose, Larry Wall created the minimal match or non-greedy quanti-
fiers "??","*?", "+?", and "{}?". These are the usual quantifiers with
a "?" appended to them. They have the following meanings:
"a??" = match 'a' 0 or 1 times. Try 0 first, then 1.
"a*?" = match 'a' 0 or more times, i.e., any number of times, but
as few times as possible
"a+?" = match 'a' 1 or more times, i.e., at least once, but as few
times as possible
"a{n,m}?" = match at least "n" times, not more than "m" times, as
few times as possible
"a{n,}?" = match at least "n" times, but as few times as possible
"a{n}?" = match exactly "n" times. Because we match exactly "n"
times, "a{n}?" is equivalent to "a{n}" and is just there for nota-
tional consistency.
Let's look(1,8,3 Search::Dict) at the example above, but with minimal quantifiers:
$x = "The programming republic of Perl";
$x =~ /^(.+?)(e|r)(.*)$/; # matches,
# $1 = 'Th'
# $2 = 'e'
# $3 = ' programming republic of Perl'
The minimal string(3,n) that will allow both the start of the string(3,n) "^" and
the alternation to match is "Th", with the alternation "e|r" matching
"e". The second quantifier ".*" is free to gobble up the rest of the
string.
$x =~ /(m{1,2}?)(.*?)$/; # matches,
# $1 = 'm'
# $2 = 'ming republic of Perl'
The first string(3,n) position that this regexp(3,n) can match is at the first
'm' in(1,8) "programming". At this position, the minimal "m{1,2}?" matches
just one 'm'. Although the second quantifier ".*?" would prefer to
match no characters, it is constrained by the end-of-string anchor "$"
to match the rest of the string.
$x =~ /(.*?)(m{1,2}?)(.*)$/; # matches,
# $1 = 'The progra'
# $2 = 'm'
# $3 = 'ming republic of Perl'
In this regexp(3,n), you might expect the first minimal quantifier ".*?" to
match the empty string(3,n), because it is not constrained by a "^" anchor
to match the beginning of the word. Principle 0 applies here, however.
Because it is possible for the whole regexp(3,n) to match at the start of
the string(3,n), it will match at the start of the string. Thus the first
quantifier has to match everything up to the first "m". The second
minimal quantifier matches just one "m" and the third quantifier
matches the rest of the string.
$x =~ /(.??)(m{1,2})(.*)$/; # matches,
# $1 = 'a'
# $2 = 'mm'
# $3 = 'ing republic of Perl'
Just as in(1,8) the previous regexp(3,n), the first quantifier ".??" can match
earliest at position 'a', so it does. The second quantifier is greedy,
so it matches "mm", and the third matches the rest of the string.
We can modify principle 3 above to take into account non-greedy quanti-
fiers:
Principle 3: If there are two or more elements in(1,8) a regexp(3,n), the
leftmost greedy (non-greedy) quantifier, if(3,n) any, will match as much
(little) of the string(3,n) as possible while still allowing the whole
regexp(3,n) to match. The next leftmost greedy (non-greedy) quantifier,
if(3,n) any, will try to match as much (little) of the string(3,n) remaining
available to it as possible, while still allowing the whole regexp(3,n)
to match. And so on, until all the regexp(3,n) elements are satisfied.
Just like alternation, quantifiers are also susceptible to backtrack-
ing. Here is a step-by-step analysis of the example
$x = "the cat in(1,8) the hat";
$x =~ /^(.*)(at)(.*)$/; # matches,
# $1 = 'the cat in(1,8) the h'
# $2 = 'at'
# $3 = '' (0 matches)
0 Start with the first letter in(1,8) the string(3,n) 't'.
1 The first quantifier '.*' starts out by matching the whole string(3,n)
'the cat in(1,8) the hat'.
2 'a' in(1,8) the regexp(3,n) element 'at' doesn't match the end of the string.
Backtrack one character.
3 'a' in(1,8) the regexp(3,n) element 'at' still doesn't match the last letter
of the string(3,n) 't', so backtrack one more character.
4 Now we can match the 'a' and the 't'.
5 Move on to the third element '.*'. Since we are at the end of the
string(3,n) and '.*' can match 0 times, assign it the empty string.
6 We are done!
Most of the time(1,2,n), all this moving forward and backtracking happens
quickly and searching is fast. There are some pathological regexps,
however, whose execution time(1,2,n) exponentially grows with the size of the
string. A typical structure that blows up in(1,8) your face is of the form
/(a|b+)*/;
The problem is the nested indeterminate quantifiers. There are many
different ways of partitioning a string(3,n) of length n between the "+" and
"*": one repetition with "b+" of length n, two repetitions with the
first "b+" length k and the second with length n-k, m repetitions whose
bits add up to length n, etc. In fact there are an exponential number
of ways to partition a string(3,n) as a function of length. A regexp(3,n) may
get lucky and match early in(1,8) the process, but if(3,n) there is no match,
perl will try every possibility before giving up. So be careful with
nested "*"'s, "{n,m}"'s, and "+"'s. The book Mastering regular expres-
sions by Jeffrey Friedl gives a wonderful discussion of this and other
efficiency issues.
Building a regexp(3,n)
At this point, we have all the basic regexp(3,n) concepts covered, so let's
give a more involved example of a regular expression. We will build a
regexp(3,n) that matches numbers.
The first task in(1,8) building a regexp(3,n) is to decide what we want to match
and what we want to exclude. In our case, we want to match both inte-
gers and floating point numbers and we want to reject any string(3,n) that
isn't a number.
The next task is to break the problem down into smaller problems that
are easily converted into a regexp.
The simplest case is integers. These consist of a sequence of digits,
with an optional sign in(1,8) front. The digits we can represent with "\d+"
and the sign can be matched with "[+-]". Thus the integer regexp(3,n) is
/[+-]?\d+/; # matches integers
A floating point number potentially has a sign, an integral part, a
decimal point, a fractional part, and an exponent. One or more of
these parts is optional, so we need to check out the different possi-
bilities. Floating point numbers which are in(1,8) proper form include
123., 0.345, .34, -1e6, and 25.4E-72. As with integers, the sign out
front is completely optional and can be matched by "[+-]?". We can see
that if(3,n) there is no exponent, floating point numbers must have a deci-
mal point, otherwise they are integers. We might be tempted to model
these with "\d*\.\d*", but this would also match just a single decimal
point, which is not a number. So the three cases of floating point
number sans exponent are
/[+-]?\d+\./; # 1., 321., etc.
/[+-]?\.\d+/; # .1, .234, etc.
/[+-]?\d+\.\d+/; # 1.0, 30.56, etc.
These can be combined into a single regexp(3,n) with a three-way alterna-
tion:
/[+-]?(\d+\.\d+|\d+\.|\.\d+)/; # floating point, no exponent
In this alternation, it is important to put '\d+\.\d+' before '\d+\.'.
If '\d+\.' were first, the regexp(3,n) would happily match that and ignore
the fractional part of the number.
Now consider floating point numbers with exponents. The key observa-
tion here is that both integers and numbers with decimal points are
allowed in(1,8) front of an exponent. Then exponents, like the overall
sign, are independent of whether we are matching numbers with or with-
out decimal points, and can be 'decoupled' from the mantissa. The
overall form of the regexp(3,n) now becomes clear:
/^(optional sign)(integer | f.p. mantissa)(optional exponent)$/;
The exponent is an "e" or "E", followed by an integer. So the exponent
regexp(3,n) is
/[eE][+-]?\d+/; # exponent
Putting all the parts together, we get a regexp(3,n) that matches numbers:
/^[+-]?(\d+\.\d+|\d+\.|\.\d+|\d+)([eE][+-]?\d+)?$/; # Ta da!
Long regexps like this may impress your friends, but can be hard to
decipher. In complex situations like this, the "//x" modifier for a
match is invaluable. It allows one to put nearly arbitrary whitespace
and comments into a regexp(3,n) without affecting their meaning. Using it,
we can rewrite our 'extended' regexp(3,n) in(1,8) the more pleasing form
/^
[+-]? # first, match an optional sign
( # then match integers or f.p. mantissas:
\d+\.\d+ # mantissa of the form a.b
|\d+\. # mantissa of the form a.
|\.\d+ # mantissa of the form .b
|\d+ # integer of the form a
)
([eE][+-]?\d+)? # finally, optionally match an exponent
$/x;
If whitespace is mostly irrelevant, how does one include space charac-
ters in(1,8) an extended regexp(3,n)? The answer is to backslash it '\ ' or put
it in(1,8) a character class "[ ]" . The same thing goes for pound signs,
use "\#" or "[#]". For instance, Perl allows a space between the sign
and the mantissa/integer, and we could add this to our regexp(3,n) as fol-
lows:
/^
[+-]?\ * # first, match an optional sign *and space*
( # then match integers or f.p. mantissas:
\d+\.\d+ # mantissa of the form a.b
|\d+\. # mantissa of the form a.
|\.\d+ # mantissa of the form .b
|\d+ # integer of the form a
)
([eE][+-]?\d+)? # finally, optionally match an exponent
$/x;
In this form, it is easier to see a way to simplify the alternation.
Alternatives 1, 2, and 4 all start with "\d+", so it could be factored
out:
/^
[+-]?\ * # first, match an optional sign
( # then match integers or f.p. mantissas:
\d+ # start out with a ...
(
\.\d* # mantissa of the form a.b or a.
)? # ? takes care of integers of the form a
|\.\d+ # mantissa of the form .b
)
([eE][+-]?\d+)? # finally, optionally match an exponent
$/x;
or written in(1,8) the compact form,
/^[+-]?\ *(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
This is our final regexp. To recap, we built a regexp(3,n) by
specifying the task in(1,8) detail,
breaking down the problem into smaller parts,
translating the small parts into regexps,
combining the regexps,
and optimizing the final combined regexp.
These are also the typical steps involved in(1,8) writing a computer pro-
gram. This makes perfect sense, because regular expressions are essen-
tially programs written a little computer language that specifies pat-
terns.
Using regular expressions in(1,8) Perl
The last topic of Part 1 briefly covers how regexps are used in(1,8) Perl
programs. Where do they fit into Perl syntax?
We have already introduced the matching operator in(1,8) its default "/reg-
exp/" and arbitrary delimiter "m!regexp(3,n)!" forms. We have used the
binding operator "=~" and its negation "!~" to test for string(3,n) matches.
Associated with the matching operator, we have discussed the single
line "//s", multi-line "//m", case-insensitive "//i" and extended "//x"
modifiers.
There are a few more things you might want to know about matching oper-
ators. First, we pointed out earlier that variables in(1,8) regexps are
substituted before the regexp(3,n) is evaluated:
$pattern = 'Seuss';
while (<>) {
print if(3,n) /$pattern/;
}
This will print any lines containing the word "Seuss". It is not as
efficient as it could be, however, because perl has to re-evaluate
$pattern each time(1,2,n) through the loop. If $pattern won't be changing
over the lifetime of the script, we can add the "//o" modifier, which
directs perl to only perform variable substitutions once:
#!/usr/bin/perl
# Improved simple_grep
$regexp(3,n) = shift;
while (<>) {
print if(3,n) /$regexp(3,n)/o; # a good deal faster
}
If you change $pattern after the first substitution happens, perl will
ignore it. If you don't want any substitutions at all, use the special
delimiter "m''":
@pattern = ('Seuss');
while (<>) {
print if(3,n) m'@pattern'; # matches literal '@pattern', not 'Seuss'
}
"m''" acts like single quotes on a regexp(3,n); all other "m" delimiters act
like double quotes. If the regexp(3,n) evaluates to the empty string(3,n), the
regexp(3,n) in(1,8) the last successful match is used instead. So we have
"dog" =~ /d/; # 'd' matches
"dogbert =~ //; # this matches the 'd' regexp(3,n) used before
The final two modifiers "//g" and "//c" concern multiple matches. The
modifier "//g" stands for global matching and allows the matching oper-
ator to match within a string(3,n) as many times as possible. In scalar
context, successive invocations against a string(3,n) will have `"//g" jump
from match to match, keeping track of position in(1,8) the string(3,n) as it goes
along. You can get or set(7,n,1 builtins) the position with the "pos()" function.
The use of "//g" is shown in(1,8) the following example. Suppose we have a
string(3,n) that consists of words separated by spaces. If we know how many
words there are in(1,8) advance, we could extract the words using groupings:
$x = "cat dog house"; # 3 words
$x =~ /^\s*(\w+)\s+(\w+)\s+(\w+)\s*$/; # matches,
# $1 = 'cat'
# $2 = 'dog'
# $3 = 'house'
But what if(3,n) we had an indeterminate number of words? This is the sort(1,3)
of task "//g" was made for. To extract all words, form the simple reg-
exp "(\w+)" and loop over all matches with "/(\w+)/g":
while ($x =~ /(\w+)/g) {
print "Word is $1, ends at position ", pos $x, "\n";
}
prints
Word is cat, ends at position 3
Word is dog, ends at position 7
Word is house, ends at position 13
A failed match or changing the target string(3,n) resets the position. If
you don't want the position reset(1,7,1 tput) after failure to match, add the
"//c", as in(1,8) "/regexp(3,n)/gc". The current position in(1,8) the string(3,n) is asso-
ciated with the string(3,n), not the regexp. This means that different
strings have different positions and their respective positions can be
set(7,n,1 builtins) or read(2,n,1 builtins) independently.
In list context, "//g" returns a list of matched groupings, or if(3,n) there
are no groupings, a list of matches to the whole regexp. So if(3,n) we
wanted just the words, we could use
@words = ($x =~ /(\w+)/g); # matches,
# $word[0] = 'cat'
# $word[1] = 'dog'
# $word[2] = 'house'
Closely associated with the "//g" modifier is the "\G" anchor. The
"\G" anchor matches at the point where the previous "//g" match left
off. "\G" allows us to easily do context-sensitive matching:
$metric = 1; # use metric units(1,7)
...
$x = <FILE>; # read(2,n,1 builtins) in(1,8) measurement
$x =~ /^([+-]?\d+)\s*/g; # get magnitude
$weight = $1;
if(3,n) ($metric) { # error(8,n) checking
print "Units error(8,n)!" unless $x =~ /\Gkg\./g;
}
else {
print "Units error(8,n)!" unless $x =~ /\Glbs\./g;
}
$x =~ /\G\s+(widget|sprocket)/g; # continue processing
The combination of "//g" and "\G" allows us to process the string(3,n) a bit
at a time(1,2,n) and use arbitrary Perl logic to decide what to do next. Cur-
rently, the "\G" anchor is only fully supported when used to anchor to
the start of the pattern.
"\G" is also invaluable in(1,8) processing fixed length records with reg-
exps. Suppose we have a snippet of coding region DNA, encoded as base
pair letters "ATCGTTGAAT..." and we want to find all the stop codons
"TGA". In a coding region, codons are 3-letter sequences, so we can
think of the DNA snippet as a sequence of 3-letter records. The naive
regexp(3,n)
# expanded, this is "ATC GTT GAA TGC AAA TGA CAT GAC"
$dna = "ATCGTTGAATGCAAATGACATGAC";
$dna =~ /TGA/;
doesn't work; it may match a "TGA", but there is no guarantee that the
match is aligned with codon boundaries, e.g., the substring "GTT GAA"
gives a match. A better solution is
while ($dna =~ /(\w\w\w)*?TGA/g) { # note the minimal *?
print "Got a TGA stop codon at position ", pos $dna, "\n";
}
which prints
Got a TGA stop codon at position 18
Got a TGA stop codon at position 23
Position 18 is good, but position 23 is bogus. What happened?
The answer is that our regexp(3,n) works well until we get past the last
real match. Then the regexp(3,n) will fail to match a synchronized "TGA"
and start stepping ahead one character position at a time(1,2,n), not what we
want. The solution is to use "\G" to anchor the match to the codon
alignment:
while ($dna =~ /\G(\w\w\w)*?TGA/g) {
print "Got a TGA stop codon at position ", pos $dna, "\n";
}
This prints
Got a TGA stop codon at position 18
which is the correct answer. This example illustrates that it is
important not only to match what is desired, but to reject what is not
desired.
search and replace
Regular expressions also play a big role in(1,8) search and replace opera-
tions in(1,8) Perl. Search and replace is accomplished with the "s///"
operator. The general form is "s/regexp(3,n)/replacement/modifiers", with
everything we know about regexps and modifiers applying in(1,8) this case as
well. The "replacement" is a Perl double quoted string(3,n) that replaces
in(1,8) the string(3,n) whatever is matched with the "regexp(3,n)"