=head1 NAME
-perlfaq6 - Regular Expressions ($Revision: 7910 $)
+perlfaq6 - Regular Expressions
=head1 DESCRIPTION
than the default, or else we won't actually ever have a multiline
record read in.
- $/ = ''; # read in more whole paragraph, not just one line
+ $/ = ''; # read in whole paragraph, not just one line
while ( <> ) {
while ( /\b([\w'-]+)(\s+\1)+\b/gi ) { # word starts alpha
print "Duplicate $1 at paragraph $.\n";
Here's code that finds sentences that begin with "From " (which would
be mangled by many mailers):
- $/ = ''; # read in more whole paragraph, not just one line
+ $/ = ''; # read in whole paragraph, not just one line
while ( <> ) {
while ( /^From /gm ) { # /m makes ^ match next to \n
print "leading from in paragraph $.\n";
$. = 0 if eof; # fix $.
}
+=head2 How do I match XML, HTML, or other nasty, ugly things with a regex?
+X<regex, XML> X<regex, HTML> X<XML> X<HTML> X<pain> X<frustration>
+X<sucking out, will to live>
+
+(contributed by brian d foy)
+
+If you just want to get work done, use a module and forget about the
+regular expressions. The C<XML::Parser> and C<HTML::Parser> modules
+are good starts, although each namespace has other parsing modules
+specialized for certain tasks and different ways of doing it. Start at
+CPAN Search ( http://search.cpan.org ) and wonder at all the work people
+have done for you already! :)
+
+The problem with things such as XML is that they have balanced text
+containing multiple levels of balanced text, but sometimes it isn't
+balanced text, as in an empty tag (C<< <br/> >>, for instance). Even then,
+things can occur out-of-order. Just when you think you've got a
+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
+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:
+
+=over 4
+
+=item * Solve the balanced text problem from another question in L<perlfaq6>
+
+=item * Try the recursive regex features in Perl 5.10 and later. See L<perlre>
+
+=item * Try defining a grammar using Perl 5.10's C<(?DEFINE)> feature.
+
+=item * Break the problem down into sub-problems instead of trying to use a single regex
+
+=item * Convince everyone not to use XML or HTML in the first place
+
+=back
+
+Good luck!
+
=head2 I put a regular expression into $/ but it didn't work. What's wrong?
X<$/, regexes in> X<$INPUT_RECORD_SEPARATOR, regexes in>
X<$RS, regexes in>
-Up to Perl 5.8.0, $/ has to be a string. This may change in 5.10,
-but don't get your hopes up. Until then, you can use these examples
-if you really need to do this.
+$/ 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
+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
complete line (using your regular expression).
local $_ = "";
while( sysread FH, $_, 8192, length ) {
- while( s/^((?s).*?)your_pattern/ ) {
+ while( s/^((?s).*?)your_pattern// ) {
my $record = $1;
# do stuff here.
}
}
- You can do the same thing with foreach and a match using the
- c flag and the \G anchor, if you do not mind your entire file
- being in memory at the end.
+You can do the same thing with foreach and a match using the
+c flag and the \G anchor, if you do not mind your entire file
+being in memory at the end.
local $_ = "";
while( sysread FH, $_, 8192, length ) {
substr($mask, -1) x (length($new) - length($old))
}
- $a = "this is a TEsT case";
- $a =~ s/(test)/preserve_case($1, "success")/egi;
- print "$a\n";
+ $string = "this is a TEsT case";
+ $string =~ s/(test)/preserve_case($1, "success")/egi;
+ print "$string\n";
This prints:
regular character, so that C<P.> matches a C<P> followed by a dot.
=head2 What is C</o> really for?
-X</o>
+X</o, regular expressions> X<compile, regular expressions>
-Using a variable in a regular expression match forces a re-evaluation
-(and perhaps recompilation) each time the regular expression is
-encountered. The C</o> modifier locks in the regex the first time
-it's used. This always happens in a constant regular expression, and
-in fact, the pattern was compiled into the internal format at the same
-time your entire program was.
+(contributed by brian d foy)
-Use of C</o> is irrelevant unless variable interpolation is used in
-the pattern, and if so, the regex engine will neither know nor care
-whether the variables change after the pattern is evaluated the I<very
-first> time.
+The C</o> option for regular expressions (documented in L<perlop> and
+L<perlreref>) tells Perl to compile the regular expression only once.
+This is only useful when the pattern contains a variable. Perls 5.6
+and later handle this automatically if the pattern does not change.
-C</o> is often used to gain an extra measure of efficiency by not
-performing subsequent evaluations when you know it won't matter
-(because you know the variables won't change), or more rarely, when
-you don't want the regex to notice if they do.
+Since the match operator C<m//>, the substitution operator C<s///>,
+and the regular expression quoting operator C<qr//> are double-quotish
+constructs, you can interpolate variables into the pattern. See the
+answer to "How can I quote a variable to use in a regex?" for more
+details.
-For example, here's a "paragrep" program:
+This example takes a regular expression from the argument list and
+prints the lines of input that match it:
- $/ = ''; # paragraph mode
- $pat = shift;
- while (<>) {
- print if /$pat/o;
- }
+ my $pattern = shift @ARGV;
+
+ while( <> ) {
+ print if m/$pattern/;
+ }
+
+Versions of Perl prior to 5.6 would recompile the regular expression
+for each iteration, even if C<$pattern> had not changed. The C</o>
+would prevent this by telling Perl to compile the pattern the first
+time, then reuse that for subsequent iterations:
+
+ my $pattern = shift @ARGV;
+
+ while( <> ) {
+ print if m/$pattern/o; # useful for Perl < 5.6
+ }
+
+In versions 5.6 and later, Perl won't recompile the regular expression
+if the variable hasn't changed, so you probably don't need the C</o>
+option. It doesn't hurt, but it doesn't help either. If you want any
+version of Perl to compile the regular expression only once even if
+the variable changes (thus, only using its initial value), you still
+need the C</o>.
+
+You can watch Perl's regular expression engine at work to verify for
+yourself if Perl is recompiling a regular expression. The C<use re
+'debug'> pragma (comes with Perl 5.005 and later) shows the details.
+With Perls before 5.6, you should see C<re> reporting that its
+compiling the regular expression on each iteration. With Perl 5.6 or
+later, you should only see C<re> report that for the first iteration.
+
+ use re 'debug';
+
+ $regex = 'Perl';
+ foreach ( qw(Perl Java Ruby Python) ) {
+ print STDERR "-" x 73, "\n";
+ print STDERR "Trying $_...\n";
+ print STDERR "\t$_ is good!\n" if m/$regex/;
+ }
=head2 How do I use a regular expression to strip C style comments from a file?
)
}{defined $2 ? $2 : ""}gxse;
-A slight modification also removes C++ comments, as long as they are not
-spread over multiple lines using a continuation character):
+A slight modification also removes C++ comments, possibly spanning multiple lines
+using a continuation character:
- s#/\*[^*]*\*+([^/*][^*]*\*+)*/|//[^\n]*|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^/"'\\]*)#defined $2 ? $2 : ""#gse;
+ s#/\*[^*]*\*+([^/*][^*]*\*+)*/|//([^\\]|[^\n][\n]?)*?\n|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^/"'\\]*)#defined $3 ? $3 : ""#gse;
=head2 Can I use Perl regular expressions to match balanced text?
X<regex, matching balanced test> X<regexp, matching balanced test>
-X<regular expression, matching balanced test>
-
-Historically, Perl regular expressions were not capable of matching
-balanced text. As of more recent versions of perl including 5.6.1
-experimental features have been added that make it possible to do this.
-Look at the documentation for the (??{ }) construct in recent perlre manual
-pages to see an example of matching balanced parentheses. Be sure to take
-special notice of the warnings present in the manual before making use
-of this feature.
-
-CPAN contains many modules that can be useful for matching text
-depending on the context. Damian Conway provides some useful
-patterns in Regexp::Common. The module Text::Balanced provides a
-general solution to this problem.
-
-One of the common applications of balanced text matching is working
-with XML and HTML. There are many modules available that support
-these needs. Two examples are HTML::Parser and XML::Parser. There
-are many others.
-
-An elaborate subroutine (for 7-bit ASCII only) to pull out balanced
-and possibly nested single chars, like C<`> and C<'>, C<{> and C<}>,
-or C<(> and C<)> can be found in
-http://www.cpan.org/authors/id/TOMC/scripts/pull_quotes.gz .
-
-The C::Scan module from CPAN also contains such subs for internal use,
-but they are undocumented.
+X<regular expression, matching balanced test> X<possessive> X<PARNO>
+X<Text::Balanced> X<Regexp::Common> X<backtracking> X<recursion>
+
+(contributed by brian d foy)
+
+Your first try should probably be the C<Text::Balanced> module, which
+is in the Perl standard library since Perl 5.8. It has a variety of
+functions to deal with tricky text. The C<Regexp::Common> module can
+also help by providing canned patterns you can use.
+
+As of Perl 5.10, you can match balanced text with regular expressions
+using recursive patterns. Before Perl 5.10, you had to resort to
+various tricks such as using Perl code in C<(??{})> sequences.
+
+Here's an example using a recursive regular expression. The goal is to
+capture all of the text within angle brackets, including the text in
+nested angle brackets. This sample text has two "major" groups: a
+group with one level of nesting and a group with two levels of
+nesting. There are five total groups in angle brackets:
+
+ I have some <brackets in <nested brackets> > and
+ <another group <nested once <nested twice> > >
+ and that's it.
+
+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
+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
+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.
+
+Putting it all together, you have:
+
+ #!/usr/local/bin/perl5.10.0
+
+ my $string =<<"HERE";
+ I have some <brackets in <nested brackets> > and
+ <another group <nested once <nested twice> > >
+ and that's it.
+ HERE
+
+ my @groups = $string =~ m/
+ ( # start of capture buffer 1
+ < # match an opening angle bracket
+ (?:
+ [^<>]++ # one or more non angle brackets, non backtracking
+ |
+ (?1) # found < or >, so recurse to capture buffer 1
+ )*
+ > # match a closing angle bracket
+ ) # end of capture buffer 1
+ /xg;
+
+ $" = "\n\t";
+ print "Found:\n\t@groups\n";
+
+The output shows that Perl found the two major groups:
+
+ Found:
+ <brackets in <nested brackets> >
+ <another group <nested once <nested twice> > >
+
+With a little extra work, you can get the all of the groups in angle
+brackets even if they are in other angle brackets too. Each time you
+get a balanced match, remove its outer delimiter (that's the one you
+just matched so don't match it again) and add it to a queue of strings
+to process. Keep doing that until you get no matches:
+
+ #!/usr/local/bin/perl5.10.0
+
+ my @queue =<<"HERE";
+ I have some <brackets in <nested brackets> > and
+ <another group <nested once <nested twice> > >
+ and that's it.
+ HERE
+
+ my $regex = qr/
+ ( # start of bracket 1
+ < # match an opening angle bracket
+ (?:
+ [^<>]++ # one or more non angle brackets, non backtracking
+ |
+ (?1) # recurse to bracket 1
+ )*
+ > # match a closing angle bracket
+ ) # end of bracket 1
+ /x;
+
+ $" = "\n\t";
+
+ while( @queue )
+ {
+ my $string = shift @queue;
+
+ my @groups = $string =~ m/$regex/g;
+ print "Found:\n\t@groups\n\n" if @groups;
+
+ unshift @queue, map { s/^<//; s/>$//; $_ } @groups;
+ }
+
+The output shows all of the groups. The outermost matches show up
+first and the nested matches so up later:
+
+ Found:
+ <brackets in <nested brackets> >
+ <another group <nested once <nested twice> > >
+
+ Found:
+ <nested brackets>
+
+ Found:
+ <nested once <nested twice> >
+
+ Found:
+ <nested twice>
=head2 What does it mean that regexes are greedy? How can I get around it?
X<greedy> X<greediness>
( 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 foreach()
+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.
@patterns = qw( foo bar baz );
}
}
-The qr// operator showed up in perl 5.005. It compiles a
+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 map() to turn each pattern into
-its pre-compiled form. The rest of the script is the same,
+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 );
{
foreach $pattern ( @patterns )
{
- print if /\b$pattern\b/i;
- next LINE;
+ if( /$pattern/ )
+ {
+ print;
+ next LINE;
+ }
}
}
In some cases, you may be able to make several patterns into
-a single regular expression. Beware of situations that require
+a single regular expression. Beware of situations that require
backtracking though.
$regex = join '|', qw( foo bar baz );
print if /\b(?:$regex)\b/i;
}
-For more details on regular expression efficiency, see Mastering
-Regular Expressions by Jeffrey Freidl. He explains how regular
+For more details on regular expression efficiency, see I<Mastering
+Regular Expressions> by Jeffrey Freidl. 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.
essentially the same information, but without the risk of excessive
string copying.
+Perl 5.10 added three specials, C<${^MATCH}>, C<${^PREMATCH}>, and
+C<${^POSTMATCH}> to do the same job but without the global performance
+penalty. Perl 5.10 only sets these variables if you compile or execute the
+regular expression with the C</p> modifier.
+
=head2 What good is C<\G> in a regular expression?
X<\G>
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 pos()
+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 pos() with the
+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
-to look at it). Each string has its own pos() value.
+to look at it). Each string has its own C<pos()> value.
-Suppose you want to match all of consective pairs of digits
+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
the letter <a> shows up between C<22> and C<44> and you want
$_ = "1122a44";
my @pairs = m/(\d\d)/g; # qw( 11 22 44 )
-If you use the \G anchor, you force the match after C<22> to
+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
there since it does not find a digit, so the next match
fails and the match operator returns the pairs it already
print "Found $1\n";
}
-After the match fails at the letter C<a>, perl resets pos()
+After the match fails at the letter C<a>, perl resets C<pos()>
and the next match on the same string starts at the beginning.
$_ = "1122a44";
print "Found $1 after while" if m/(\d\d)/g; # finds "11"
-You can disable pos() resets on fail with the C<c> flag.
-Subsequent matches start where the last successful match
-ended (the value of pos()) even if a match on the same
-string as failed in the meantime. In this case, the match
-after the while() loop starts at the C<a> (where the last
-match stopped), and since it does not use any anchor it can
-skip over the C<a> to find "44".
+You can disable C<pos()> resets on fail with the C<c> flag, documented
+in L<perlop> and L<perlreref>. Subsequent matches start where the last
+successful match ended (the value of C<pos()>) even if a match on the
+same string has failed in the meantime. In this case, the match after
+the C<while()> loop starts at the C<a> (where the last match stopped),
+and since it does not use any anchor it can skip over the C<a> to find
+C<44>.
$_ = "1122a44";
while( m/\G(\d\d)/gc )
}
}
-For each line, the PARSER loop first tries to match a series
+For each line, the C<PARSER> loop first tries to match a series
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
=head1 REVISION
-Revision: $Revision: 7910 $
+Revision: $Revision$
-Date: $Date: 2006-10-07 22:38:54 +0200 (sam, 07 oct 2006) $
+Date: $Date$
See L<perlfaq> for source control details and availability.
=head1 AUTHOR AND COPYRIGHT
-Copyright (c) 1997-2006 Tom Christiansen, Nathan Torkington, and
+Copyright (c) 1997-2009 Tom Christiansen, Nathan Torkington, and
other authors as noted. All rights reserved.
This documentation is free; you can redistribute it and/or modify it
projects / p5sagit/p5-mst-13.2.git / blobdiff