=head1 NAME
-perlfaq6 - Regular Expressions ($Revision: 7910 $)
+perlfaq6 - Regular Expressions
=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 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
+ while ( /\b([\w'-]+)(\s+\g1)+\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, 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:
+
+=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
-a buffer. After you add to the buffer, you check if you have a
+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 ) {
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";
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:
=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.";
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?
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
)
}{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.
-
-=head2 What does it mean that regexes are greedy? How can I get around it?
+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 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 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 group 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 group 1
+ < # match an opening angle bracket
+ (?:
+ [^<>]++ # one or more non angle brackets, non backtracking
+ |
+ (?1) # found < or >, so recurse to capture group 1
+ )*
+ > # match a closing angle bracket
+ ) # end of capture group 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>
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 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 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,
-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 )
- {
- print if /\b$pattern\b/i;
- next LINE;
+ LINE: while( <> ) {
+ foreach $pattern ( @patterns ) {
+ 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
-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 Mastering
-Regular Expressions by Jeffrey Freidl. He explains how regular
+For more details on regular expression efficiency, see I<Mastering
+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.
+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>
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 pos()
-as the position to start the next match. As the match
-operator makes successive matches, it updates pos() with 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
+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
+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>.
$_ = "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
-start with the C<a>. The regular expression cannot match
+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
found.
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
-of digits followed by a word boundary. This match has to
+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
)/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: 7910 $
-
-Date: $Date: 2006-10-07 22:38:54 +0200 (sam, 07 oct 2006) $
-
-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-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