X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperlretut.pod;h=67e06700d4d8130a072d4be1379216e8301816c2;hb=ee4d0b42de4ba63c06ae897c6cb13e6c67a3f0c2;hp=5ff4298012c041828ca49f1b79bc9bf3ca8c2f53;hpb=a6b2f353992254a6ec5c40c60b053f7a6817c8e4;p=p5sagit%2Fp5-mst-13.2.git
diff --git a/pod/perlretut.pod b/pod/perlretut.pod
index 5ff4298..67e0670 100644
--- a/pod/perlretut.pod
+++ b/pod/perlretut.pod
@@ -59,9 +59,9 @@ contains that word:
"Hello World" =~ /World/; # matches
-What is this perl statement all about? C<"Hello World"> is a simple
+What is this Perl statement all about? C<"Hello World"> is a simple
double quoted string. C is the regular expression and the
-C/> enclosing C tells perl to search a string for a match.
+C/> enclosing C tells Perl to search a string for a match.
The operator C<=~> associates the string with the regexp match and
produces a true value if the regexp matched, or false if the regexp
did not match. In our case, C matches the second word in
@@ -76,7 +76,7 @@ are useful in conditionals:
}
There are useful variations on this theme. The sense of the match can
-be reversed by using C operator:
+be reversed by using the C operator:
if ("Hello World" !~ /World/) {
print "It doesn't match\n";
@@ -115,8 +115,8 @@ to arbitrary delimiters by putting an C<'m'> out front:
# '/' becomes an ordinary char
C, C, and C all represent the
-same thing. When, e.g., C<""> is used as a delimiter, the forward
-slash C<'/'> becomes an ordinary character and can be used in a regexp
+same thing. When, e.g., the quote (C<">) is used as a delimiter, the forward
+slash C<'/'> becomes an ordinary character and can be used in this regexp
without trouble.
Let's consider how different regexps would match C<"Hello World">:
@@ -128,7 +128,7 @@ Let's consider how different regexps would match C<"Hello World">:
The first regexp C doesn't match because regexps are
case-sensitive. The second regexp matches because the substring
-S > occurs in the string S >. The space
+S> occurs in the string S>. The space
character ' ' is treated like any other character in a regexp and is
needed to match in this case. The lack of a space character is the
reason the third regexp C<'oW'> doesn't match. The fourth regexp
@@ -137,7 +137,7 @@ regexp, but not at the end of the string. The lesson here is that
regexps must match a part of the string I in order for the
statement to be true.
-If a regexp matches in more than one place in the string, perl will
+If a regexp matches in more than one place in the string, Perl will
always match at the earliest possible point in the string:
"Hello World" =~ /o/; # matches 'o' in 'Hello'
@@ -145,7 +145,7 @@ always match at the earliest possible point in the string:
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 a match. Some characters, called B, are reserved
+is' in a match. Some characters, called I, are reserved
for use in regexp notation. The metacharacters are
{}[]()^$.|*+?\
@@ -158,13 +158,14 @@ that a metacharacter can be matched by putting a backslash before it:
"2+2=4" =~ /2\+2/; # matches, \+ is treated like an ordinary +
"The interval is [0,1)." =~ /[0,1)./ # is a syntax error!
"The interval is [0,1)." =~ /\[0,1\)\./ # matches
- "/usr/bin/perl" =~ /\/usr\/local\/bin\/perl/; # matches
+ "#!/usr/bin/perl" =~ /#!\/usr\/bin\/perl/; # matches
In the last regexp, the forward slash C<'/'> is also backslashed,
because it is used to delimit the regexp. This can lead to LTS
(leaning toothpick syndrome), however, and it is often more readable
to change delimiters.
+ "#!/usr/bin/perl" =~ m!#\!/usr/bin/perl!; # easier to read
The backslash character C<'\'> is a metacharacter itself and needs to
be backslashed:
@@ -173,7 +174,7 @@ be backslashed:
In addition to the metacharacters, there are some ASCII characters
which don't have printable character equivalents and are instead
-represented by B. Common examples are C<\t> for a
+represented by I. Common examples are C<\t> for a
tab, C<\n> for a newline, C<\r> for a carriage return and C<\a> for a
bell. If your string is better thought of as a sequence of arbitrary
bytes, the octal escape sequence, e.g., C<\033>, or hexadecimal escape
@@ -225,17 +226,17 @@ Here is a I emulation of the Unix grep program:
This program is easy to understand. C<#!/usr/bin/perl> is the standard
way to invoke a perl program from the shell.
-S > saves the first command line argument as the
+S> saves the first command line argument as the
regexp to be used, leaving the rest of the command line arguments to
-be treated as files. S) >> > loops over all the lines in
-all the files. For each line, S > prints the
+be treated as files. S) >>> loops over all the lines in
+all the files. For each line, S> prints the
line if the regexp matches the line. In this line, both C and
C$regexp/> use the default variable C<$_> implicitly.
With all of the regexps above, if the regexp matched anywhere in the
string, it was considered a match. Sometimes, however, we'd like to
specify I in the string the regexp should try to match. To do
-this, we would use the B metacharacters C<^> and C<$>. The
+this, we would use the I metacharacters C<^> and C<$>. The
anchor C<^> means match at the beginning of the string and the anchor
C<$> means match at the end of the string, or before a newline at the
end of the string. Here is how they are used:
@@ -275,7 +276,7 @@ bert, off in a string by himself:
"bert" =~ /^bert$/; # matches, perfect
Of course, in the case of a literal string, one could just as easily
-use the string equivalence S > and it would be
+use the string comparison S> and it would be
more efficient. The C<^...$> regexp really becomes useful when we
add in the more powerful regexp tools below.
@@ -288,7 +289,7 @@ concepts (and associated metacharacter notations) that will allow a
regexp to not just represent a single character sequence, but a I of them.
-One such concept is that of a B. A character class
+One such concept is that of a I. 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 C<[...]>, with the set of characters
@@ -306,11 +307,11 @@ 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 a case-insensitive
-match. Perl provides away of avoiding all those brackets by simply
+This regexp displays a common task: perform a case-insensitive
+match. Perl provides a way of avoiding all those brackets by simply
appending an C<'i'> to the end of the match. Then C[yY][eE][sS]/;>
can be rewritten as C. The C<'i'> stands for
-case-insensitive and is an example of a B of the matching
+case-insensitive and is an example of a I 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
@@ -318,8 +319,9 @@ represented themselves, and special characters, which needed a
backslash C<\> 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 C<-]\^$>. C<]>
-is special because it denotes the end of a character class. C<$> is
+class. The special characters for a character class are C<-]\^$> (and
+the pattern delimiter, whatever it is).
+C<]> is special because it denotes the end of a character class. C<$> is
special because it denotes a scalar variable. C<\> is special because
it is used in escape sequences, just like above. Here is how the
special characters C<]$\> are handled:
@@ -330,7 +332,7 @@ special characters C<]$\> are handled:
/[\$x]at/; # matches '$at' or 'xat'
/[\\$x]at/; # matches '\at', 'bat, 'cat', or 'rat'
-The last two are a little tricky. in C<[\$x]>, the backslash protects
+The last two are a little tricky. In C<[\$x]>, the backslash protects
the dollar sign, so the character class has two members C<$> and C.
In C<[\\$x]>, the backslash is protected, so C<$x> is treated as a
variable and substituted in double quote fashion.
@@ -344,15 +346,15 @@ become the svelte C<[0-9]> and C<[a-z]>. Some examples are
/[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 an alphanumeric character,
- # like those in a perl variable name
+ /[0-9a-zA-Z_]/; # matches a "word" character,
+ # like those in a Perl variable name
If C<'-'> is the first or last character in a character class, it is
treated as an ordinary character; C<[-ab]>, C<[ab-]> and C<[a\-b]> are
all equivalent.
The special character C<^> in the first position of a character class
-denotes a B, which matches any character but
+denotes a I, which matches any character but
those in the brackets. Both C<[...]> and C<[^...]> must match a
character, or the match fails. Then
@@ -361,32 +363,43 @@ character, or the match fails. Then
/[^0-9]/; # matches a non-numeric character
/[a^]at/; # matches 'aat' or '^at'; here '^' is ordinary
-Now, even C<[0-9]> can be a bother the write multiple times, so in the
+Now, even C<[0-9]> can be a bother to write multiple times, so in the
interest of saving keystrokes and making regexps more readable, Perl
-has several abbreviations for common character classes:
+has several abbreviations for common character classes, as shown below.
+Since the introduction of Unicode, these character classes match more
+than just a few characters in the ISO 8859-1 range.
=over 4
=item *
-\d is a digit and represents [0-9]
+
+\d matches a digit, not just [0-9] but also digits from non-roman scripts
=item *
-\s is a whitespace character and represents [\ \t\r\n\f]
+
+\s matches a whitespace character, the set [\ \t\r\n\f] and others
=item *
-\w is a word character (alphanumeric or _) and represents [0-9a-zA-Z_]
+
+\w matches a word character (alphanumeric or _), not just [0-9a-zA-Z_]
+but also digits and characters from non-roman scripts
=item *
-\D is a negated \d; it represents any character but a digit [^0-9]
+
+\D is a negated \d; it represents any other character than a digit, or [^\d]
=item *
+
\S is a negated \s; it represents any non-whitespace character [^\s]
=item *
+
\W is a negated \w; it represents any non-word character [^\w]
=item *
-The period '.' matches any character but "\n"
+
+The period '.' matches any character but "\n" (unless the modifier C/s> is
+in effect, as explained below).
=back
@@ -407,7 +420,7 @@ of characters, it is incorrect to think of C<[^\d\w]> as C<[\D\W]>; in
fact C<[^\d\w]> is the same as C<[^\w]>, which is the same as
C<[\W]>. Think DeMorgan's laws.
-An anchor useful in basic regexps is the S >
+An anchor useful in basic regexps is the I
C<\b>. This matches a boundary between a word character and a non-word
character C<\w\W> or C<\W\w>:
@@ -424,16 +437,16 @@ You might wonder why C<'.'> matches everything but C<"\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 C<"\n"> represents one line, we would like to think
-of as empty. Then
+of it as empty. Then
"" =~ /^$/; # matches
- "\n" =~ /^$/; # matches, "\n" is ignored
+ "\n" =~ /^$/; # matches, $ anchors before "\n"
"" =~ /./; # 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"
+ "a\n" =~ /^.$/; # matches, $ anchors before "\n"
This behavior is convenient, because we usually want to ignore
newlines when we count and match characters in a line. Sometimes,
@@ -451,22 +464,26 @@ and C<$> are able to match. Here are the four possible combinations:
=over 4
=item *
+
no modifiers (//): Default behavior. C<'.'> matches any character
except C<"\n">. C<^> matches only at the beginning of the string and
C<$> matches only at the end or before a newline at the end.
=item *
+
s modifier (//s): Treat string as a single long line. C<'.'> matches
any character, even C<"\n">. C<^> matches only at the beginning of
the string and C<$> matches only at the end or before a newline at the
end.
=item *
+
m modifier (//m): Treat string as a set of multiple lines. C<'.'>
matches any character except C<"\n">. C<^> and C<$> are able to match
at the start or end of I line within the string.
=item *
+
both s and m modifiers (//sm): Treat string as a single long line, but
detect multiple lines. C<'.'> matches any character, even
C<"\n">. C<^> and C<$>, however, are able to match at the start or end
@@ -488,9 +505,9 @@ Here are examples of C/s> and C/m> in action:
$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 C/s> and
+Most of the time, the default behavior is what is wanted, but C/s> and
C/m> are occasionally very useful. If C/m> is being used, the start
-of the string can still be matched with C<\A> and the end of string
+of the string can still be matched with C<\A> and the end of the string
can still be matched with the anchors C<\Z> (matches both the end and
the newline before, like C<$>), and C<\z> (matches only the end):
@@ -509,15 +526,15 @@ choices are described in the next section.
=head2 Matching this or that
-Sometimes we would like to our regexp to be able to match different
+Sometimes we would like our regexp to be able to match different
possible words or character strings. This is accomplished by using
-the B metacharacter C<|>. To match C or C, we
-form the regexp C. As before, perl will try to match the
+the I metacharacter C<|>. To match C or C, we
+form the regexp C. As before, Perl will try to match the
regexp at the earliest possible point in the string. At each
-character position, perl will first try to match the first
-alternative, C. If C doesn't match, perl will then try the
+character position, Perl will first try to match the first
+alternative, C. If C doesn't match, Perl will then try the
next alternative, C. If C doesn't match either, then the
-match fails and perl moves to the next position in the string. Some
+match fails and Perl moves to the next position in the string. Some
examples:
"cats and dogs" =~ /cat|dog|bird/; # matches "cat"
@@ -539,21 +556,21 @@ to give them a chance to match.
The last example points out that character classes are like
alternations of characters. At a given character position, the first
-alternative that allows the regexp match to succeed wil be the one
+alternative that allows the regexp match to succeed will be the one
that matches.
=head2 Grouping things and hierarchical matching
Alternation allows a regexp to choose among alternatives, but by
-itself it unsatisfying. The reason is that each alternative is a whole
+itself it is unsatisfying. The reason is that each alternative is a whole
regexp, but sometime we want alternatives for just part of a
regexp. For instance, suppose we want to search for housecats or
housekeepers. The regexp C fits the bill, but is
inefficient because we had to type C twice. It would be nice to
-have parts of the regexp be constant, like C, and and some
+have parts of the regexp be constant, like C, and some
parts have alternatives, like C.
-The B metacharacters C<()> solve this problem. Grouping
+The I metacharacters C<()> solve this problem. Grouping
allows parts of a regexp to be treated as a single unit. Parts of a
regexp are grouped by enclosing them in parentheses. Thus we could solve
the C by forming the regexp as
@@ -576,15 +593,16 @@ are
Alternations behave the same way in groups as out of them: at a given
string position, the leftmost alternative that allows the regexp to
-match is taken. So in the last example at tth first string position,
+match is taken. So in the last example at the first string position,
C<"20"> matches the second alternative, but there is nothing left over
-to match the next two digits C<\d\d>. So perl moves on to the next
+to match the next two digits C<\d\d>. So Perl moves on to the next
alternative, which is the null alternative and that works, since
C<"20"> is two digits.
The process of trying one alternative, seeing if it matches, and
-moving on to the next alternative if it doesn't, is called
-B. The term 'backtracking' comes from the idea that
+moving on to the next alternative, while going back in the string
+from where the previous alternative was tried, if it doesn't, is called
+I. The term 'backtracking' comes from the idea that
matching a regexp is like a walk in the woods. Successfully matching
a regexp is like arriving at a destination. There are many possible
trailheads, one for each string position, and each one is tried in
@@ -596,38 +614,58 @@ destination, you stop immediately and forget about trying all the
other trails. You are persistent, and only if 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
+of what Perl does when it tries to match the regexp
"abcde" =~ /(abd|abc)(df|d|de)/;
=over 4
-=item 0 Start with the first letter in the string 'a'.
+=item 0
+
+Start with the first letter in the string 'a'.
+
+=item 1
+
+Try the first alternative in the first group 'abd'.
+
+=item 2
-=item 1 Try the first alternative in the first group 'abd'.
+Match 'a' followed by 'b'. So far so good.
-=item 2 Match 'a' followed by 'b'. So far so good.
+=item 3
-=item 3 'd' in the regexp doesn't match 'c' in the string - a dead
+'d' in the regexp doesn't match 'c' in the string - a dead
end. So backtrack two characters and pick the second alternative in
the first group 'abc'.
-=item 4 Match 'a' followed by 'b' followed by 'c'. We are on a roll
+=item 4
+
+Match 'a' followed by 'b' followed by 'c'. We are on a roll
and have satisfied the first group. Set $1 to 'abc'.
-=item 5 Move on to the second group and pick the first alternative
+=item 5
+
+Move on to the second group and pick the first alternative
'df'.
-=item 6 Match the 'd'.
+=item 6
+
+Match the 'd'.
+
+=item 7
-=item 7 'f' in the regexp doesn't match 'e' in the string, so a dead
+'f' in the regexp doesn't match 'e' in the string, so a dead
end. Backtrack one character and pick the second alternative in the
second group 'd'.
-=item 8 'd' matches. The second grouping is satisfied, so set $2 to
+=item 8
+
+'d' matches. The second grouping is satisfied, so set $2 to
'd'.
-=item 9 We are at the end of the regexp, so we are done! We have
+=item 9
+
+We are at the end of the regexp, so we are done! We have
matched 'abcd' out of the string "abcde".
=back
@@ -637,16 +675,16 @@ third alternative in 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
position of the string 'a'. If there were no matches at the first
-position, perl would move to the second character position 'b' and
+position, Perl would 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 give
-up and declare S > to be false.
+possible character positions have been exhausted does Perl give
+up and declare S> to be false.
Even with all this work, regexp matching happens remarkably fast. To
-speed things up, during compilation stage, perl compiles the regexp
-into a compact sequence of opcodes that can often fit inside a
-processor cache. When the code is executed, these opcodes can then run
-at full throttle and search very quickly.
+speed things up, Perl compiles the regexp into a compact sequence of
+opcodes that can often fit inside a processor cache. When the code is
+executed, these opcodes can then run at full throttle and search very
+quickly.
=head2 Extracting matches
@@ -658,13 +696,14 @@ inside goes into the special variables C<$1>, C<$2>, etc. They can be
used just as ordinary variables:
# extract hours, minutes, seconds
- $time =~ /(\d\d):(\d\d):(\d\d)/; # match hh:mm:ss format
- $hours = $1;
- $minutes = $2;
- $seconds = $3;
+ if ($time =~ /(\d\d):(\d\d):(\d\d)/) { # match hh:mm:ss format
+ $hours = $1;
+ $minutes = $2;
+ $seconds = $3;
+ }
Now, we know that in scalar context,
-S > returns a true or false
+S> returns a true or false
value. In list context, however, it returns the list of matched values
C<($1,$2,$3)>. So we could write the code more compactly as
@@ -673,28 +712,39 @@ C<($1,$2,$3)>. So we could write the code more compactly as
If the groupings in a regexp are nested, C<$1> gets the group with the
leftmost opening parenthesis, C<$2> the next opening parenthesis,
-etc. For example, here is a complex regexp and the matching variables
-indicated below it:
+etc. Here is a regexp with nested groups:
/(ab(cd|ef)((gi)|j))/;
1 2 34
-so that if the regexp matched, e.g., C<$2> would contain 'cd' or 'ef'.
-For convenience, perl sets C<$+> to the highest numbered C<$1>, C<$2>,
-... that got assigned.
+If this regexp matches, C<$1> contains a string starting with
+C<'ab'>, C<$2> is either set to C<'cd'> or C<'ef'>, C<$3> equals either
+C<'gi'> or C<'j'>, and C<$4> is either set to C<'gi'>, just like C<$3>,
+or it remains undefined.
+
+For convenience, Perl sets C<$+> to the string held by the highest numbered
+C<$1>, C<$2>,... that got assigned (and, somewhat related, C<$^N> to the
+value of the C<$1>, C<$2>,... most-recently assigned; i.e. the C<$1>,
+C<$2>,... associated with the rightmost closing parenthesis used in the
+match).
+
+
+=head2 Backreferences
Closely associated with the matching variables C<$1>, C<$2>, ... are
-the B C<\1>, C<\2>, ... . Backreferences are simply
+the I C<\1>, C<\2>,... Backreferences are simply
matching variables that can be used I a regexp. This is a
-really nice feature - what matches later in a regexp can depend on
+really nice feature -- what matches later in a regexp is made to depend on
what matched earlier in the regexp. Suppose we wanted to look
-for doubled words in text, like 'the the'. The following regexp finds
+for doubled words in a text, like 'the the'. The following regexp finds
all 3-letter doubles with a space in between:
- /(\w\w\w)\s\1/;
+ /\b(\w\w\w)\s\1\b/;
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:
+is used for both parts.
+
+A similar task is to find words consisting of two identical parts:
% simple_grep '^(\w\w\w\w|\w\w\w|\w\w|\w)\1$' /usr/dict/words
beriberi
@@ -705,14 +755,106 @@ is used for both parts. Here are some words with repeated parts:
papa
The regexp has a single grouping which considers 4-letter
-combinations, then 3-letter combinations, etc. and uses C<\1> to look for
+combinations, then 3-letter combinations, etc., and uses C<\1> to look for
a repeat. Although C<$1> and C<\1> represent the same thing, care should be
-taken to use matched variables C<$1>, C<$2>, ... only outside a regexp
-and backreferences C<\1>, C<\2>, ... only inside a regexp; not doing
-so may lead to surprising and/or undefined results.
+taken to use matched variables C<$1>, C<$2>,... only I a regexp
+and backreferences C<\1>, C<\2>,... only I a regexp; not doing
+so may lead to surprising and unsatisfactory results.
+
+
+=head2 Relative backreferences
+
+Counting the opening parentheses to get the correct number for a
+backreference is errorprone as soon as there is more than one
+capturing group. A more convenient technique became available
+with Perl 5.10: relative backreferences. To refer to the immediately
+preceding capture group one now may write C<\g{-1}>, the next but
+last is available via C<\g{-2}>, and so on.
+
+Another good reason in addition to readability and maintainability
+for using relative backreferences is illustrated by the following example,
+where a simple pattern for matching peculiar strings is used:
-In addition to what was matched, Perl 5.6.0 also provides the
-positions of what was matched with the C<@-> and C<@+>
+ $a99a = '([a-z])(\d)\2\1'; # matches a11a, g22g, x33x, etc.
+
+Now that we have this pattern stored as a handy string, we might feel
+tempted to use it as a part of some other pattern:
+
+ $line = "code=e99e";
+ if ($line =~ /^(\w+)=$a99a$/){ # unexpected behavior!
+ print "$1 is valid\n";
+ } else {
+ print "bad line: '$line'\n";
+ }
+
+But this doesn't match -- at least not the way one might expect. Only
+after inserting the interpolated C<$a99a> and looking at the resulting
+full text of the regexp is it obvious that the backreferences have
+backfired -- the subexpression C<(\w+)> has snatched number 1 and
+demoted the groups in C<$a99a> by one rank. This can be avoided by
+using relative backreferences:
+
+ $a99a = '([a-z])(\d)\g{-1}\g{-2}'; # safe for being interpolated
+
+
+=head2 Named backreferences
+
+Perl 5.10 also introduced named capture buffers and named backreferences.
+To attach a name to a capturing group, you write either
+C<< (?...) >> or C<< (?'name'...) >>. The backreference may
+then be written as C<\g{name}>. It is permissible to attach the
+same name to more than one group, but then only the leftmost one of the
+eponymous set can be referenced. Outside of the pattern a named
+capture buffer is accessible through the C<%+> hash.
+
+Assuming that we have to match calendar dates which may be given in one
+of the three formats yyyy-mm-dd, mm/dd/yyyy or dd.mm.yyyy, we can write
+three suitable patterns where we use 'd', 'm' and 'y' respectively as the
+names of the buffers capturing the pertaining components of a date. The
+matching operation combines the three patterns as alternatives:
+
+ $fmt1 = '(?\d\d\d\d)-(?\d\d)-(?\d\d)';
+ $fmt2 = '(?\d\d)/(?\d\d)/(?\d\d\d\d)';
+ $fmt3 = '(?\d\d)\.(?\d\d)\.(?\d\d\d\d)';
+ for my $d qw( 2006-10-21 15.01.2007 10/31/2005 ){
+ if ( $d =~ m{$fmt1|$fmt2|$fmt3} ){
+ print "day=$+{d} month=$+{m} year=$+{y}\n";
+ }
+ }
+
+If any of the alternatives matches, the hash C<%+> is bound to contain the
+three key-value pairs.
+
+
+=head2 Alternative capture group numbering
+
+Yet another capturing group numbering technique (also as from Perl 5.10)
+deals with the problem of referring to groups within a set of alternatives.
+Consider a pattern for matching a time of the day, civil or military style:
+
+ if ( $time =~ /(\d\d|\d):(\d\d)|(\d\d)(\d\d)/ ){
+ # process hour and minute
+ }
+
+Processing the results requires an additional if statement to determine
+whether C<$1> and C<$2> or C<$3> and C<$4> contain the goodies. It would
+be easier if we could use buffer numbers 1 and 2 in second alternative as
+well, and this is exactly what the parenthesized construct C<(?|...)>,
+set around an alternative achieves. Here is an extended version of the
+previous pattern:
+
+ if ( $time =~ /(?|(\d\d|\d):(\d\d)|(\d\d)(\d\d))\s+([A-Z][A-Z][A-Z])/ ){
+ print "hour=$1 minute=$2 zone=$3\n";
+ }
+
+Within the alternative numbering group, buffer numbers start at the same
+position for each alternative. After the group, numbering continues
+with one higher than the maximum reached across all the alternatives.
+
+=head2 Position information
+
+In addition to what was matched, Perl (since 5.6.0) also provides the
+positions of what was matched as contents of the C<@-> and C<@+>
arrays. C<$-[0]> is the position of the start of the entire match and
C<$+[0]> is the position of the end. Similarly, C<$-[n]> is the
position of the start of the C<$n> match and C<$+[n]> is the position
@@ -731,7 +873,7 @@ prints
Match 2: 'donut' at position (6,11)
Even if there are no groupings in a regexp, it is still possible to
-find out what exactly matched in a string. If you use them, perl
+find out what exactly matched in a string. If you use them, Perl
will set C<$`> to the part of the string before the match, will set C<$&>
to the part of the string that matched, and will set C<$'> to the part
of the string after the match. An example:
@@ -740,54 +882,99 @@ of the string after the match. An example:
$x =~ /cat/; # $` = 'the ', $& = 'cat', $' = ' caught the mouse'
$x =~ /the/; # $` = '', $& = 'the', $' = ' cat caught the mouse'
-In the second match, S > because the regexp matched at the
-first character position in the string and stopped, it never saw the
+In the second match, C<$`> equals C<''> because the regexp matched at the
+first character position in the string and stopped; it never saw the
second 'the'. It is important to note that using C<$`> and C<$'>
-slows down regexp matching quite a bit, and C< $& > slows it down to a
+slows down regexp matching quite a bit, while C<$&> slows it down to a
lesser extent, because if they are used in one regexp in a program,
-they are generated for regexps in the program. So if raw
+they are generated for I regexps in the program. So if raw
performance is a goal of your application, they should be avoided.
-If you need them, use C<@-> and C<@+> instead:
+If you need to extract the corresponding substrings, use C<@-> and
+C<@+> 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] )
+
+=head2 Non-capturing groupings
+
+A group that is required to bundle a set of alternatives may or may not be
+useful as a capturing group. If it isn't, it just creates a superfluous
+addition to the set of available capture buffer values, inside as well as
+outside the regexp. Non-capturing groupings, denoted by C<(?:regexp)>,
+still allow the regexp to be treated as a single unit, but don't establish
+a capturing buffer at the same time. Both capturing and non-capturing
+groupings are allowed to co-exist in the same regexp. Because there is
+no extraction, non-capturing groupings are faster than capturing
+groupings. Non-capturing groupings are also handy for choosing exactly
+which parts of a regexp are to be extracted to matching variables:
+
+ # match a number, $1-$4 are set, but we only want $1
+ /([+-]?\ *(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?)/;
+
+ # match a number faster , only $1 is set
+ /([+-]?\ *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)/;
+
+ # match a number, get $1 = whole number, $2 = exponent
+ /([+-]?\ *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE]([+-]?\d+))?)/;
+
+Non-capturing groupings are also useful for removing nuisance
+elements gathered from a split operation where parentheses are
+required for some reason:
+
+ $x = '12aba34ba5';
+ @num = split /(a|b)+/, $x; # @num = ('12','a','34','b','5')
+ @num = split /(?:a|b)+/, $x; # @num = ('12','34','5')
+
+
=head2 Matching repetitions
The examples in 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
+were only matching 3-letter words, or chunks of words of 4 letters or
+less. We'd like to be able to match words or, more generally, strings
+of any length, without writing out tedious alternatives like
C<\w\w\w\w|\w\w\w|\w\w|\w>.
-This is exactly the problem the B metacharacters C>,
-C<*>, C<+>, and C<{}> were created for. They allow us to determine the
-number of repeats of a portion of a regexp we consider to be a
+This is exactly the problem the I metacharacters C>,
+C<*>, C<+>, and C<{}> were created for. They allow us to delimit the
+number of repeats for a portion of a regexp we consider to be a
match. Quantifiers are put immediately after the character, character
class, or grouping that we want to specify. They have the following
meanings:
=over 4
-=item * C = match 'a' 1 or 0 times
+=item *
-=item * C = match 'a' 0 or more times, i.e., any number of times
+C means: match 'a' 1 or 0 times
-=item * C = match 'a' 1 or more times, i.e., at least once
+=item *
+
+C means: match 'a' 0 or more times, i.e., any number of times
+
+=item *
-=item * C = match at least C times, but not more than C
+C means: match 'a' 1 or more times, i.e., at least once
+
+=item *
+
+C means: match at least C times, but not more than C
times.
-=item * C = match at least C or more times
+=item *
+
+C means: match at least C or more times
+
+=item *
-=item * C = match exactly C times
+C means: match exactly C times
=back
Here are some examples:
- /[a-z]+\s+\d*/; # match a lowercase word, at least some space, and
+ /[a-z]+\s+\d*/; # match a lowercase word, at least one 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'
@@ -805,10 +992,10 @@ Here are some examples:
murmur
papa
-For all of these quantifiers, perl will try to match as much of the
+For all of these quantifiers, Perl will try to match as much of the
string as possible, while still allowing the regexp to succeed. Thus
-with C, perl will first try to match the regexp with the C
-present; if that fails, perl will try to match the regexp without the
+with C, Perl will first try to match the regexp with the C
+present; if that fails, Perl will try to match the regexp without the
C present. For the quantifier C<*>, we get the following:
$x = "the cat in the hat";
@@ -823,9 +1010,9 @@ string and locks onto it. Consider, however, this regexp:
$x =~ /^(.*)(at)(.*)$/; # matches,
# $1 = 'the cat in the h'
# $2 = 'at'
- # $3 = '' (0 matches)
+ # $3 = '' (0 characters match)
-One might initially guess that perl would find the C in C and
+One might initially guess that Perl would find the C in C and
stop there, but that wouldn't give the longest possible string to the
first quantifier C<.*>. Instead, the first quantifier C<.*> grabs as
much of the string as possible while still having the regexp match. In
@@ -836,8 +1023,8 @@ quantifier, if there is one, gets to grab as much the string as
possible, leaving the rest of the regexp to fight over scraps. Thus in
our example, the first quantifier C<.*> grabs most of the string, while
the second quantifier C<.*> gets the empty string. Quantifiers that
-grab as much of the string as possible are called B or
-B quantifiers.
+grab as much of the string as possible are called I or
+I quantifiers.
When a regexp can match a string in several different ways, we can use
the principles above to predict which way the regexp will match:
@@ -845,19 +1032,23 @@ the principles above to predict which way the regexp will match:
=over 4
=item *
+
Principle 0: Taken as a whole, any regexp will be matched at the
earliest possible position in the string.
=item *
+
Principle 1: In an alternation C, the leftmost alternative
that allows a match for the whole regexp will be the one used.
=item *
+
Principle 2: The maximal matching quantifiers C>, C<*>, C<+> and
C<{n,m}> will in general match as much of the string as possible while
still allowing the whole regexp to match.
=item *
+
Principle 3: If there are two or more elements in a regexp, the
leftmost greedy quantifier, if any, will match as much of the string
as possible while still allowing the whole regexp to match. The next
@@ -868,7 +1059,7 @@ satisfied.
=back
-As we have seen above, Principle 0 overrides the others - the regexp
+As we have seen above, Principle 0 overrides the others -- the regexp
will be matched as early as possible, with the other principles
determining how the regexp matches at that earliest character
position.
@@ -918,28 +1109,40 @@ C, not C.
Sometimes greed is not good. At times, we would like quantifiers to
match a I piece of string, rather than a maximal piece. For
-this purpose, Larry Wall created the S > or
-B quantifiers C?>,C<*?>, C<+?>, and C<{}?>. These are
+this purpose, Larry Wall created the I or
+I quantifiers C?>, C<*?>, C<+?>, and C<{}?>. These are
the usual quantifiers with a C> appended to them. They have the
following meanings:
=over 4
-=item * C = match 'a' 0 or 1 times. Try 0 first, then 1.
+=item *
+
+C means: match 'a' 0 or 1 times. Try 0 first, then 1.
-=item * C = match 'a' 0 or more times, i.e., any number of times,
+=item *
+
+C means: match 'a' 0 or more times, i.e., any number of times,
but as few times as possible
-=item * C = match 'a' 1 or more times, i.e., at least once, but
+=item *
+
+C means: match 'a' 1 or more times, i.e., at least once, but
as few times as possible
-=item * C = match at least C times, not more than C
+=item *
+
+C means: match at least C times, not more than C
times, as few times as possible
-=item * C = match at least C times, but as few times as
+=item *
+
+C means: match at least C times, but as few times as
possible
-=item * C = match exactly C times. Because we match exactly
+=item *
+
+C means: match exactly C times. Because we match exactly
C times, C is equivalent to C and is just there for
notational consistency.
@@ -998,6 +1201,7 @@ quantifiers:
=over 4
=item *
+
Principle 3: If there are two or more elements in a regexp, the
leftmost greedy (non-greedy) quantifier, if any, will match as much
(little) of the string as possible while still allowing the whole
@@ -1019,28 +1223,42 @@ backtracking. Here is a step-by-step analysis of the example
=over 4
-=item 0 Start with the first letter in the string 't'.
+=item 0
+
+Start with the first letter in the string 't'.
-=item 1 The first quantifier '.*' starts out by matching the whole
+=item 1
+
+The first quantifier '.*' starts out by matching the whole
string 'the cat in the hat'.
-=item 2 'a' in the regexp element 'at' doesn't match the end of the
+=item 2
+
+'a' in the regexp element 'at' doesn't match the end of the
string. Backtrack one character.
-=item 3 'a' in the regexp element 'at' still doesn't match the last
+=item 3
+
+'a' in the regexp element 'at' still doesn't match the last
letter of the string 't', so backtrack one more character.
-=item 4 Now we can match the 'a' and the 't'.
+=item 4
-=item 5 Move on to the third element '.*'. Since we are at the end of
+Now we can match the 'a' and the 't'.
+
+=item 5
+
+Move on to the third element '.*'. Since we are at the end of
the string and '.*' can match 0 times, assign it the empty string.
-=item 6 We are done!
+=item 6
+
+We are done!
=back
Most of the time, all this moving forward and backtracking happens
-quickly and searching is fast. There are some pathological regexps,
+quickly and searching is fast. There are some pathological regexps,
however, whose execution time exponentially grows with the size of the
string. A typical structure that blows up in your face is of the form
@@ -1051,13 +1269,71 @@ different ways of partitioning a string of length n between the C<+>
and C<*>: one repetition with C of length n, two repetitions with
the first C 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 as a function of length. A
+number of ways to partition a string as a function of its length. A
regexp may get lucky and match early in the process, but if there is
-no match, perl will try I possibility before giving up. So be
+no match, Perl will try I possibility before giving up. So be
careful with nested C<*>'s, C<{n,m}>'s, and C<+>'s. The book
-I by Jeffrey Friedl gives a wonderful
+I by Jeffrey Friedl gives a wonderful
discussion of this and other efficiency issues.
+
+=head2 Possessive quantifiers
+
+Backtracking during the relentless search for a match may be a waste
+of time, particularly when the match is bound to fail. Consider
+the simple pattern
+
+ /^\w+\s+\w+$/; # a word, spaces, a word
+
+Whenever this is applied to a string which doesn't quite meet the
+pattern's expectations such as S> or S>,
+the regex engine will backtrack, approximately once for each character
+in the string. But we know that there is no way around taking I
+of the initial word characters to match the first repetition, that I
+spaces must be eaten by the middle part, and the same goes for the second
+word.
+
+With the introduction of the I in Perl 5.10, we
+have a way of instructing the regex engine not to backtrack, with the
+usual quantifiers with a C<+> appended to them. This makes them greedy as
+well as stingy; once they succeed they won't give anything back to permit
+another solution. They have the following meanings:
+
+=over 4
+
+=item *
+
+C means: match at least C times, not more than C times,
+as many times as possible, and don't give anything up. C is short
+for C
+
+=item *
+
+C means: match at least C times, but as many times as possible,
+and don't give anything up. C is short for C and C is
+short for C.
+
+=item *
+
+C means: match exactly C times. It is just there for
+notational consistency.
+
+=back
+
+These possessive quantifiers represent a special case of a more general
+concept, the I, see below.
+
+As an example where a possessive quantifier is suitable we consider
+matching a quoted string, as it appears in several programming languages.
+The backslash is used as an escape character that indicates that the
+next character is to be taken literally, as another character for the
+string. Therefore, after the opening quote, we expect a (possibly
+empty) sequence of alternatives: either some character except an
+unescaped quote or backslash or an escaped character.
+
+ /"(?:[^"\\]++|\\.)*+"/;
+
+
=head2 Building a regexp
At this point, we have all the basic regexp concepts covered, so let's
@@ -1089,7 +1365,7 @@ see that if there is no exponent, floating point numbers must have a
decimal point, otherwise they are integers. We might be tempted to
model these with C<\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
+point number without exponent are
/[+-]?\d+\./; # 1., 321., etc.
/[+-]?\.\d+/; # .1, .234, etc.
@@ -1140,9 +1416,9 @@ we can rewrite our 'extended' regexp in the more pleasing form
If whitespace is mostly irrelevant, how does one include space
characters in an extended regexp? The answer is to backslash it
-S > or put it in a character class S >. The same thing
+S> or put it in a character class S>. The same thing
goes for pound signs, use C<\#> or C<[#]>. For instance, Perl allows
-a space between the sign and the mantissa/integer, and we could add
+a space between the sign and the mantissa or integer, and we could add
this to our regexp as follows:
/^
@@ -1180,21 +1456,31 @@ This is our final regexp. To recap, we built a regexp by
=over 4
-=item * specifying the task in detail,
+=item *
-=item * breaking down the problem into smaller parts,
+specifying the task in detail,
-=item * translating the small parts into regexps,
+=item *
-=item * combining the regexps,
+breaking down the problem into smaller parts,
-=item * and optimizing the final combined regexp.
+=item *
+
+translating the small parts into regexps,
+
+=item *
+
+combining the regexps,
+
+=item *
+
+and optimizing the final combined regexp.
=back
These are also the typical steps involved in writing a computer
program. This makes perfect sense, because regular expressions are
-essentially programs written a little computer language that specifies
+essentially programs written in a little computer language that specifies
patterns.
=head2 Using regular expressions in Perl
@@ -1207,11 +1493,13 @@ C and arbitrary delimiter C forms. We have used
the binding operator C<=~> and its negation C to test for string
matches. Associated with the matching operator, we have discussed the
single line C/s>, multi-line C/m>, case-insensitive C/i> and
-extended C/x> modifiers.
+extended C/x> modifiers. There are a few more things you might
+want to know about matching operators.
+
+=head3 Optimizing pattern evaluation
-There are a few more things you might want to know about matching
-operators. First, we pointed out earlier that variables in regexps are
-substituted before the regexp is evaluated:
+We pointed out earlier that variables in regexps are substituted
+before the regexp is evaluated:
$pattern = 'Seuss';
while (<>) {
@@ -1219,10 +1507,10 @@ substituted before the regexp is evaluated:
}
This will print any lines containing the word C. It is not as
-efficient as it could be, however, because perl has to re-evaluate
-C<$pattern> each time through the loop. If C<$pattern> won't be
+efficient as it could be, however, because Perl has to re-evaluate
+(or compile) C<$pattern> each time through the loop. If C<$pattern> won't be
changing over the lifetime of the script, we can add the C/o>
-modifier, which directs perl to only perform variable substitutions
+modifier, which directs Perl to only perform variable substitutions
once:
#!/usr/bin/perl
@@ -1232,24 +1520,30 @@ once:
print if /$regexp/o; # a good deal faster
}
-If you change C<$pattern> after the first substitution happens, perl
+
+=head3 Prohibiting substitution
+
+If you change C<$pattern> after the first substitution happens, Perl
will ignore it. If you don't want any substitutions at all, use the
special delimiter C:
- $pattern = 'Seuss';
+ @pattern = ('Seuss');
while (<>) {
- print if m'$pattern'; # matches '$pattern', not 'Seuss'
+ print if m'@pattern'; # matches literal '@pattern', not 'Seuss'
}
-C acts like single quotes on a regexp; all other C delimiters
-act like double quotes. If the regexp evaluates to the empty string,
+Similar to strings, C acts like apostrophes on a regexp; all other
+C delimiters act like quotes. If the regexp evaluates to the empty string,
the regexp in the I is used instead. So we have
"dog" =~ /d/; # 'd' matches
"dogbert =~ //; # this matches the 'd' regexp used before
+
+=head3 Global matching
+
The final two modifiers C/g> and C/c> concern multiple matches.
-The modifier C/g> stands for global matching and allows the the
+The modifier C/g> stands for global matching and allows the
matching operator to match within a string as many times as possible.
In scalar context, successive invocations against a string will have
`C/g> jump from match to match, keeping track of position in the
@@ -1316,6 +1610,8 @@ off. C<\G> allows us to easily do context-sensitive matching:
The combination of C/g> and C<\G> allows us to process the string a
bit at a time and use arbitrary Perl logic to decide what to do next.
+Currently, the C<\G> anchor is only fully supported when used to anchor
+to the start of the pattern.
C<\G> is also invaluable in processing fixed length records with
regexps. Suppose we have a snippet of coding region DNA, encoded as
@@ -1328,9 +1624,9 @@ naive regexp
$dna = "ATCGTTGAATGCAAATGACATGAC";
$dna =~ /TGA/;
-doesn't work; it may match an C, but there is no guarantee that
+doesn't work; it may match a C, but there is no guarantee that
the match is aligned with codon boundaries, e.g., the substring
-S > gives a match. A better solution is
+S> 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";
@@ -1361,9 +1657,9 @@ 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.
-B
+=head3 Search and replace
-Regular expressions also play a big role in B
+Regular expressions also play a big role in I
operations in Perl. Search and replace is accomplished with the
C operator. The general form is
C, with everything we know about
@@ -1371,7 +1667,7 @@ regexps and modifiers applying in this case as well. The
C is a Perl double quoted string that replaces in the
string whatever is matched with the C. The operator C<=~> is
also used here to associate a string with C. If matching
-against C<$_>, the S > can be dropped. If there is a match,
+against C<$_>, the S> can be dropped. If there is a match,
C returns the number of substitutions made, otherwise it returns
false. Here are a few examples:
@@ -1449,15 +1745,14 @@ quoted strings and there are no substitutions. C in list context
returns the same thing as in scalar context, i.e., the number of
matches.
-B
+=head3 The split function
-The B > function can also optionally use a matching operator
-C to split a string. C splits
-C into a list of substrings and returns that list. The regexp
-is used to match the character sequence that the C is split
-with respect to. The C, if present, constrains splitting into
-no more than C number of strings. For example, to split a
-string into words, use
+The C function is another place where a regexp is used.
+C separates the C operand into
+a list of substrings and returns that list. The regexp must be designed
+to match whatever constitutes the separators for the desired substrings.
+The C, if present, constrains splitting into no more than C
+number of strings. For example, to split a string into words, use
$x = "Calvin and Hobbes";
@words = split /\s+/, $x; # $word[0] = 'Calvin'
@@ -1466,7 +1761,7 @@ string into words, use
If the empty regexp C/> is used, the regexp always matches and
the string is split into individual characters. If the regexp has
-groupings, then list produced contains the matched substrings from the
+groupings, then the resulting list contains the matched substrings from the
groupings as well. For instance,
$x = "/usr/bin/perl";
@@ -1498,11 +1793,11 @@ OK, you know the basics of regexps and you want to know more. If
matching regular expressions is analogous to a walk in the woods, then
the tools discussed in Part 1 are analogous to topo maps and a
compass, basic tools we use all the time. Most of the tools in part 2
-are are analogous to flare guns and satellite phones. They aren't used
+are analogous to flare guns and satellite phones. They aren't used
too often on a hike, but when we are stuck, they can be invaluable.
What follows are the more advanced, less used, or sometimes esoteric
-capabilities of perl regexps. In Part 2, we will assume you are
+capabilities of Perl regexps. In Part 2, we will assume you are
comfortable with the basics and concentrate on the new features.
=head2 More on characters, strings, and character classes
@@ -1511,16 +1806,17 @@ There are a number of escape sequences and character classes that we
haven't covered yet.
There are several escape sequences that convert characters or strings
-between upper and lower case. C<\l> and C<\u> convert the next
-character to lower or upper case, respectively:
+between upper and lower case, and they are also available within
+patterns. C<\l> and C<\u> convert the next character to lower or
+upper case, respectively:
$x = "perl";
$string =~ /\u$x/; # matches 'Perl' in $string
$x = "M(rs?|s)\\."; # note the double backslash
$string =~ /\l$x/; # matches 'mr.', 'mrs.', and 'ms.',
-C<\L> and C<\U> converts a whole substring, delimited by C<\L> or
-C<\U> and C<\E>, to lower or upper case:
+A C<\L> or C<\U> indicates a lasting conversion of case, until
+terminated by C<\E> or thrown over by another C<\U> or C<\L>:
$x = "This word is in lower case:\L SHOUT\E";
$x =~ /shout/; # matches
@@ -1543,49 +1839,45 @@ instance,
It does not protect C<$> or C<@>, so that variables can still be
substituted.
-With the advent of 5.6.0, perl regexps can handle more than just the
-standard ASCII character set. Perl now supports B, a standard
-for encoding the character sets from many of the world's written
-languages. Unicode does this by allowing characters to be more than
-one byte wide. Perl uses the UTF-8 encoding, in which ASCII characters
-are still encoded as one byte, but characters greater than C
-may be stored as two or more bytes.
+With the advent of 5.6.0, Perl regexps can handle more than just the
+standard ASCII character set. Perl now supports I, a standard
+for representing the alphabets from virtually all of the world's written
+languages, and a host of symbols. Perl's text strings are Unicode strings, so
+they can contain characters with a value (codepoint or character number) higher
+than 255
What does this mean for regexps? Well, regexp users don't need to know
-much about perl's internal representation of strings. But they do need
-to know 1) how to represent Unicode characters in a regexp and 2) when
-a matching operation will treat the string to be searched as a
-sequence of bytes (the old way) or as a sequence of Unicode characters
-(the new way). The answer to 1) is that Unicode characters greater
-than C may be represented using the C<\x{hex}> notation,
-with C a hexadecimal integer:
-
- use utf8; # We will be doing Unicode processing
+much about Perl's internal representation of strings. But they do need
+to know 1) how to represent Unicode characters in a regexp and 2) that
+a matching operation will treat the string to be searched as a sequence
+of characters, not bytes. The answer to 1) is that Unicode characters
+greater than C are represented using the C<\x{hex}> notation,
+because the \0 octal and \x hex (without curly braces) don't go further
+than 255.
+
/\x{263a}/; # match a Unicode smiley face :)
-Unicode characters in the range of 128-255 use two hexadecimal digits
-with braces: C<\x{ab}>. Note that this is different than C<\xab>,
-which is just a hexadecimal byte with no Unicode
-significance.
+B: In Perl 5.6.0 it used to be that one needed to say C