=head1 DESCRIPTION
This section is surprisingly small because the rest of the FAQ is
-littered with answers involving regular expressions. For example,
+littered with answers involving regular expressions. For example,
decoding a URL and checking whether something is a number are handled
with regular expressions, but those answers are found elsewhere in
this document (in L<perlfaq9>: "How do I decode or create those %-encodings
=item Comments Inside the Regex
The C</x> modifier causes whitespace to be ignored in a regex pattern
-(except in a character class), and also allows you to use normal
-comments there, too. As you can imagine, whitespace and comments help
-a lot.
+(except in a character class and a few other places), and also allows you to
+use normal comments there, too. As you can imagine, whitespace and comments
+help a lot.
C</x> lets you turn this:
=item Different Delimiters
While we normally think of patterns as being delimited with C</>
-characters, they can be delimited by almost any character.
L<perlre>
-describes this. For example, the C<s///> above uses braces as
-delimiters. Selecting another delimiter can avoid quoting the
+characters, they can be delimited by almost any character. L<perlre>
+describes this. For example, the C<s///> above uses braces as
+delimiters. Selecting another delimiter can avoid quoting the
delimiter within the pattern:
s/\/usr\/local/\/usr\/share/g; # bad delimiter choice
=back
-=head2 I'm having trouble matching over more than one line. What's wrong?
+=head2 I'm having trouble matching over more than one line. What's wrong?
X<regex, multiline> X<regexp, multiline> X<regular expression, multiline>
Either you don't have more than one line in the string you're looking
at (probably), or else you aren't using the correct modifier(s) on
your pattern (possibly).
-There are many ways to get multiline data into a string. If you want
+There are many ways to get multiline data into a string. If you want
it to happen automatically while reading input, you'll want to set $/
(probably to '' for paragraphs or C<undef> for the whole file) to
allow you to read more than one line at a time.
Read L<perlre> to help you decide which of C</s> and C</m> (or both)
you might want to use: C</s> allows dot to include newline, and C</m>
allows caret and dollar to match next to a newline, not just at the
-end of the string. You do need to make sure that you've actually
+end of the string. You do need to make sure that you've actually
got a multiline string in there.
For example, this program detects duplicate words, even when they span
-line breaks (but not paragraph ones). For this example, we don't need
+line breaks (but not paragraph ones). For this example, we don't need
C</s> because we aren't using dot in a regular expression that we want
-to cross line boundaries. Neither do we need C</m> because we aren't
+to cross line boundaries. Neither do we need C</m> because we aren't
wanting caret or dollar to match at any point inside the record next
-to newlines. But it's imperative that $/ be set to something other
+to newlines. But it's imperative that $/ be set to something other
than the default, or else we won't actually ever have a multiline
record read in.
$/ = ''; # read in whole paragraph, not just one line
while ( <> ) {
- while ( /\b([\w'-]+)(\s+\1)+\b/gi ) { # word starts alpha
+ while ( /\b([\w'-]+)(\s+\g1)+\b/gi ) { # word starts alpha
print "Duplicate $1 at paragraph $.\n";
}
}
pattern that matches your input, someone throws you a curveball.
If you'd like to do it the hard way, scratching and clawing your way
-toward a right answer but constantly being disappointed, beseiged by
+toward a right answer but constantly being disappointed, besieged by
bug reports, and weary from the inordinate amount of time you have to
spend reinventing a triangular wheel, then there are several things
you can try before you give up in frustration:
X<$/, regexes in> X<$INPUT_RECORD_SEPARATOR, regexes in>
X<$RS, regexes in>
-$/ has to be a string. You can use these examples if you really need to
+$/ has to be a string. You can use these examples if you really need to
do this.
If you have File::Stream, this is easy.
If you don't have File::Stream, you have to do a little more work.
You can use the four-argument form of sysread to continually add to
-a buffer. After you add to the buffer, you check if you have a
+a buffer. After you add to the buffer, you check if you have a
complete line (using your regular expression).
local $_ = "";
X<replace, case preserving> X<substitute, case preserving>
X<substitution, case preserving> X<s, case preserving>
-Here's a lovely Perlish solution by Larry Rosler. It exploits
+Here's a lovely Perlish solution by Larry Rosler. It exploits
properties of bitwise xor on ASCII strings.
$_= "this is a TEsT case";
=head2 How can I make C<\w> match national character sets?
X<\w>
-Put C<use locale;> in your script. The \w character class is taken
+Put C<use locale;> in your script. The \w character class is taken
from the current locale.
See L<perllocale> for details.
No matter which locale you are in, the alphabetic characters are
the characters in \w without the digits and the underscore.
-As a regex, that looks like C</[^\W\d_]/>. Its complement,
+As a regex, that looks like C</[^\W\d_]/>. Its complement,
the non-alphabetics, is then everything in \W along with
the digits and the underscore, or C</[\W\d_]/>.
X<regex, escaping> X<regexp, escaping> X<regular expression, escaping>
The Perl parser will expand $variable and @variable references in
-regular expressions unless the delimiter is a single quote. Remember,
+regular expressions unless the delimiter is a single quote. Remember,
too, that the right-hand side of a C<s///> substitution is considered
-a double-quoted string (see L<perlop> for more details). Remember
+a double-quoted string (see L<perlop> for more details). Remember
also that any regex special characters will be acted on unless you
-precede the substitution with \Q. Here's an example:
+precede the substitution with \Q. Here's an example:
$string = "Placido P. Octopus";
$regex = "P.";
perl -0777 -pe 's{/\*.*?\*/}{}gs' foo.c
-will work in many but not all cases. You see, it's too simple-minded for
+will work in many but not all cases. You see, it's too simple-minded for
certain kinds of C programs, in particular, those with what appear to be
-comments in quoted strings. For that, you'd need something like this,
+comments in quoted strings. For that, you'd need something like this,
created by Jeffrey Friedl and later modified by Fred Curtis.
$/ = undef;
print;
This could, of course, be more legibly written with the C</x> modifier, adding
-whitespace and comments. Here it is expanded, courtesy of Fred Curtis.
+whitespace and comments. Here it is expanded, courtesy of Fred Curtis.
s{
/\* ## Start of /* ... */ comment
<another group <nested once <nested twice> > >
and that's it.
-The regular expression to match the balanced text uses two new (to
+The regular expression to match the balanced text uses two new (to
Perl 5.10) regular expression features. These are covered in L<perlre>
and this example is a modified version of one in that documentation.
-First, adding the new possesive C<+> to any quantifier finds the
+First, adding the new possessive C<+> to any quantifier finds the
longest match and does not backtrack. That's important since you want
to handle any angle brackets through the recursion, not backtracking.
The group C<< [^<>]++ >> finds one or more non-angle brackets without
backtracking.
Second, the new C<(?PARNO)> refers to the sub-pattern in the
-particular capture
buffer given by C<PARNO>. In the following regex,
-the first capture buffer finds (and remembers) the balanced text, and
-you need that same pattern within the first buffer to get past the
+particular capture
group given by C<PARNO>. In the following regex,
+the first capture group finds (and remembers) the balanced text, and
+you need that same pattern within the first buffer to get past the
nested text. That's the recursive part. The C<(?1)> uses the pattern
-in the outer capture buffer as an independent part of the regex.
+in the outer capture group as an independent part of the regex.
Putting it all together, you have:
HERE
my @groups = $string =~ m/
- ( # start of capture buffer 1
+ ( # start of capture group 1
< # match an opening angle bracket
(?:
[^<>]++ # one or more non angle brackets, non backtracking
|
- (?1) # found < or >, so recurse to capture buffer 1
+ (?1) # found < or >, so recurse to capture group 1
)*
> # match a closing angle bracket
- ) # end of capture buffer 1
+ ) # end of capture group 1
/xg;
$" = "\n\t";
Found:
<nested twice>
-=head2 What does it mean that regexes are greedy? How can I get around it?
+=head2 What does it mean that regexes are greedy? How can I get around it?
X<greedy> X<greediness>
Most people mean that greedy regexes match as much as they can.
Technically speaking, it's actually the quantifiers (C<?>, C<*>, C<+>,
C<{}>) that are greedy rather than the whole pattern; Perl prefers local
-greed and immediate gratification to overall greed. To get non-greedy
+greed and immediate gratification to overall greed. To get non-greedy
versions of the same quantifiers, use (C<??>, C<*?>, C<+?>, C<{}?>).
An example:
$s2 =~ s/ve.*?y //; # I am very cold
Notice how the second substitution stopped matching as soon as it
-encountered "y ". The C<*?> quantifier effectively tells the regular
+encountered "y ". The C<*?> quantifier effectively tells the regular
expression engine to find a match as quickly as possible and pass
control on to whatever is next in line, like you would if you were
playing hot potato.
=head2 How can I print out a word-frequency or line-frequency summary?
-To do this, you have to parse out each word in the input stream. We'll
+To do this, you have to parse out each word in the input stream. We'll
pretend that by word you mean chunk of alphabetics, hyphens, or
apostrophes, rather than the non-whitespace chunk idea of a word given
in the previous question:
X<regex, efficiency> X<regexp, efficiency>
X<regular expression, efficiency>
-( contributed by brian d foy )
+(contributed by brian d foy)
-Avoid asking Perl to compile a regular expression every time
-you want to match it. In this example, perl must recompile
-the regular expression for every iteration of the C<foreach>
-loop since it has no way to know what $pattern will be.
+If you have Perl 5.10 or later, this is almost trivial. You just smart
+match against an array of regular expression objects:
- @patterns = qw( foo bar baz );
+ my @patterns = ( qr/Fr.d/, qr/B.rn.y/, qr/W.lm./ );
+
+ if( $string ~~ @patterns ) {
+ ...
+ };
- LINE: while( <DATA> )
- {
- foreach $pattern ( @patterns )
- {
- if( /\b$pattern\b/i )
- {
+The smart match stops when it finds a match, so it doesn't have to try
+every expression.
+
+Earlier than Perl 5.10, you have a bit of work to do. You want to
+avoid compiling a regular expression every time you want to match it.
+In this example, perl must recompile the regular expression for every
+iteration of the C<foreach> loop since it has no way to know what
+C<$pattern> will be:
+
+ my @patterns = qw( foo bar baz );
+
+ LINE: while( <DATA> ) {
+ foreach $pattern ( @patterns ) {
+ if( /\b$pattern\b/i ) {
print;
next LINE;
}
}
}
-The C<qr//> operator showed up in perl 5.005. It compiles a
-regular expression, but doesn't apply it. When you use the
-pre-compiled version of the regex, perl does less work. In
-this example, I inserted a C<map> to turn each pattern into
-its pre-compiled form. The rest of the script is the same,
-but faster.
+The C<qr//> operator showed up in perl 5.005. It compiles a regular
+expression, but doesn't apply it. When you use the pre-compiled
+version of the regex, perl does less work. In this example, I inserted
+a C<map> to turn each pattern into its pre-compiled form. The rest of
+the script is the same, but faster:
- @patterns = map { qr/\b$_\b/i } qw( foo bar baz );
+ my @patterns = map { qr/\b$_\b/i } qw( foo bar baz );
- LINE: while( <> )
- {
- foreach $pattern ( @patterns )
- {
+ LINE: while( <> ) {
+ foreach $pattern ( @patterns ) {
if( /$pattern/ )
{
print;
}
}
-In some cases, you may be able to make several patterns into
-a single regular expression. Beware of situations that require
-backtracking though.
+In some cases, you may be able to make several patterns into a single
+regular expression. Beware of situations that require backtracking
+though.
- $regex = join '|', qw( foo bar baz );
+ my $regex = join '|', qw( foo bar baz );
- LINE: while( <> )
- {
+ LINE: while( <> ) {
print if /\b(?:$regex)\b/i;
}
For more details on regular expression efficiency, see I<Mastering
-Regular Expressions> by Jeffrey Freidl. He explains how regular
+Regular Expressions> by Jeffrey Friedl. He explains how regular
expressions engine work and why some patterns are surprisingly
-inefficient. Once you understand how perl applies regular
-expressions, you can tune them for individual situations.
+inefficient. Once you understand how perl applies regular expressions,
+you can tune them for individual situations.
=head2 Why don't word-boundary searches with C<\b> work for me?
X<\b>
condition at a certain position.
For the regular expression, /\bPerl\b/, there has to be a word
-boundary before the "P" and after the "l". As long as something other
+boundary before the "P" and after the "l". As long as something other
than a word character precedes the "P" and succeeds the "l", the
pattern will match. These strings match /\bPerl\b/.
"Perl_" # _ is a word char!
"Perler" # no word char before P, but one after l
-You don't have to use \b to match words though. You can look for
-non-word characters surrounded by word characters. These strings
+You don't have to use \b to match words though. You can look for
+non-word characters surrounded by word characters. These strings
match the pattern /\b'\b/.
"don't" # the ' char is surrounded by "n" and "t"
longer "expensive" the way the other two are.
Since Perl 5.6.1 the special variables @- and @+ can functionally replace
-$`, $& and $'. These arrays contain pointers to the beginning and end
+$`, $& and $'. These arrays contain pointers to the beginning and end
of each match (see perlvar for the full story), so they give you
essentially the same information, but without the risk of excessive
string copying.
X<\G>
You use the C<\G> anchor to start the next match on the same
-string where the last match left off. The regular
+string where the last match left off. The regular
expression engine cannot skip over any characters to find
the next match with this anchor, so C<\G> is similar to the
-beginning of string anchor, C<^>. The C<\G> anchor is typically
-used with the C<g> flag.
It uses the value of C<pos()>
-as the position to start the next match. As the match
+beginning of string anchor, C<^>. The C<\G> anchor is typically
+used with the C<g> flag. It uses the value of C<pos()>
+as the position to start the next match. As the match
operator makes successive matches, it updates C<pos()> with the
position of the next character past the last match (or the
first character of the next match, depending on how you like
Suppose you want to match all of consecutive pairs of digits
in a string like "1122a44" and stop matching when you
-encounter non-digits. You want to match C<11> and C<22> but
+encounter non-digits. You want to match C<11> and C<22> but
the letter <a> shows up between C<22> and C<44> and you want
to stop at C<a>. Simply matching pairs of digits skips over
the C<a> and still matches C<44>.
my @pairs = m/(\d\d)/g; # qw( 11 22 44 )
If you use the C<\G> anchor, you force the match after C<22> to
-start with the C<a>. The regular expression cannot match
+start with the C<a>. The regular expression cannot match
there since it does not find a digit, so the next match
fails and the match operator returns the pairs it already
found.
}
For each line, the C<PARSER> loop first tries to match a series
-of digits followed by a word boundary. This match has to
+of digits followed by a word boundary. This match has to
start at the place the last match left off (or the beginning
of the string on the first match). Since C<m/ \G( \d+\b
)/gcx> uses the C<c> flag, if the string does not match that
match starts at the same position to try a different
pattern.
-=head2 Are Perl regexes DFAs or NFAs? Are they POSIX compliant?
+=head2 Are Perl regexes DFAs or NFAs? Are they POSIX compliant?
X<DFA> X<NFA> X<POSIX>
While it's true that Perl's regular expressions resemble the DFAs
(deterministic finite automata) of the egrep(1) program, they are in
fact implemented as NFAs (non-deterministic finite automata) to allow
-backtracking and backreferencing. And they aren't POSIX-style either,
-because those guarantee worst-case behavior for all cases. (It seems
+backtracking and backreferencing. And they aren't POSIX-style either,
+because those guarantee worst-case behavior for all cases. (It seems
that some people prefer guarantees of consistency, even when what's
-guaranteed is slowness.) See the book "Mastering Regular Expressions"
+guaranteed is slowness.) See the book "Mastering Regular Expressions"
(from O'Reilly) by Jeffrey Friedl for all the details you could ever
hope to know on these matters (a full citation appears in
L<perlfaq2>).
X<regular expression, and multibyte characters> X<martian> X<encoding, Martian>
Starting from Perl 5.6 Perl has had some level of multibyte character
-support. Perl 5.8 or later is recommended. Supported multibyte
+support. Perl 5.8 or later is recommended. Supported multibyte
character repertoires include Unicode, and legacy encodings
-through the Encode module.
See L<perluniintro>, L<perlunicode>,
+through the Encode module. See L<perluniintro>, L<perlunicode>,
and L<Encode>.
If you are stuck with older Perls, you can do Unicode with the
C<Unicode::String> module, and character conversions using the
-C<Unicode::Map8> and C<Unicode::Map> modules. If you are using
+C<Unicode::Map8> and C<Unicode::Map> modules. If you are using
Japanese encodings, you might try using the jperl 5.005_03.
Finally, the following set of approaches was offered by Jeffrey
Now, say you want to search for the single character C</GX/>. Perl
doesn't know about Martian, so it'll find the two bytes "GX" in the "I
-am CVSGXX!" string, even though that character isn't there: it just
+am CVSGXX!" string, even though that character isn't there: it just
looks like it is because "SG" is next to "XX", but there's no real
-"GX". This is a big problem.
+"GX". This is a big problem.
Here are a few ways, all painful, to deal with it:
/x;
This succeeds if the "martian" character GX is in the string, and fails
-otherwise. If you don't like using (?<!), a zero-width negative
+otherwise. If you don't like using (?<!), a zero-width negative
look-behind assertion, you can replace (?<![A-Z]) with (?:^|[^A-Z]).
It does have the drawback of putting the wrong thing in $-[0] and $+[0],
if( $string =~ m/\Q$regex\E/ ) { ... }
Alternately, you can use C<qr//>, the regular expression quote operator (see
-L<perlop> for more details). It quotes and perhaps compiles the pattern,
+L<perlop> for more details). It quotes and perhaps compiles the pattern,
and you can apply regular expression flags to the pattern.
chomp( my $input = <STDIN> );
warn $@;
}
-=head1 REVISION
-
-Revision: $Revision$
-
-Date: $Date$
-
-See L<perlfaq> for source control details and availability.
-
=head1 AUTHOR AND COPYRIGHT
-Copyright (c) 1997-2009 Tom Christiansen, Nathan Torkington, and
+Copyright (c) 1997-2010 Tom Christiansen, Nathan Torkington, and
other authors as noted. All rights reserved.
This documentation is free; you can redistribute it and/or modify it
under the same terms as Perl itself.
Irrespective of its distribution, all code examples in this file
-are hereby placed into the public domain. You are permitted and
+are hereby placed into the public domain. You are permitted and
encouraged to use this code in your own programs for fun
-or for profit as you see fit. A simple comment in the code giving
+or for profit as you see fit. A simple comment in the code giving
credit would be courteous but is not required.
https://perl5.git.perl.org / perl5.git / blobdiff