|
perlfaq6 - Regular Expressions ($Revision: 8539 $)
This section is surprisingly small because the rest of the FAQ is
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 the perlfaq9 manpage: "How do I decode or create those %-encodings
on the web" and the perlfaq4 manpage: "How do I determine whether a scalar is
a number/whole/integer/float", to be precise).
Three techniques can make regular expressions maintainable and
understandable.
- Comments Outside the Regex
-
Describe what you're doing and how you're doing it, using normal Perl
comments.
-
s/^(\w+)(.*)/ lc($1) . ":" . length($2) /meg;
- Comments Inside the Regex
-
The /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.
-
/x lets you turn this:
-
s{<(?:[^>'"]*|".*?"|'.*?')+>}{}gs;
-
into this:
-
s{ < # opening angle bracket
(?: # Non-backreffing grouping paren
[^>'"] * # 0 or more things that are neither > nor ' nor "
| # or else
".*?" # a section between double quotes (stingy match)
| # or else
'.*?' # a section between single quotes (stingy match)
) + # all occurring one or more times
> # closing angle bracket
}{}gsx;
-
It's still not quite so clear as prose, but it is very useful for
describing the meaning of each part of the pattern.
- Different Delimiters
-
While we normally think of patterns as being delimited with /
characters, they can be delimited by almost any character. the perlre manpage
describes this. For example, the s/// above uses braces as
delimiters. Selecting another delimiter can avoid quoting the
delimiter within the pattern:
-
s/\/usr\/local/\/usr\/share/g;
s#/usr/local#/usr/share#g;
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
it to happen automatically while reading input, you'll want to set $/
(probably to '' for paragraphs or undef for the whole file) to
allow you to read more than one line at a time.
Read the perlre manpage to help you decide which of /s and /m (or both)
you might want to use: /s allows dot to include newline, and /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
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
/s because we aren't using dot in a regular expression that we want
to cross line boundaries. Neither do we need /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
than the default, or else we won't actually ever have a multiline
record read in.
$/ = '';
while ( <> ) {
while ( /\b([\w'-]+)(\s+\1)+\b/gi ) {
print "Duplicate $1 at paragraph $.\n";
}
}
Here's code that finds sentences that begin with "From " (which would
be mangled by many mailers):
$/ = '';
while ( <> ) {
while ( /^From /gm ) {
print "leading from in paragraph $.\n";
}
}
Here's code that finds everything between START and END in a paragraph:
undef $/;
while ( <> ) {
while ( /START(.*?)END/sgm ) {
print "$1\n";
}
}
You can use Perl's somewhat exotic .. operator (documented in
the perlop manpage):
perl -ne 'print if /START/ .. /END/' file1 file2 ...
If you wanted text and not lines, you would use
perl -0777 -ne 'print "$1\n" while /START(.*?)END/gs' file1 file2 ...
But if you want nested occurrences of START through END, you'll
run up against the problem described in the question in this section
on matching balanced text.
Here's another example of using ..:
while (<>) {
$in_header = 1 .. /^$/;
$in_body = /^$/ .. eof;
} continue {
$. = 0 if eof;
}
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.
If you have File::Stream, this is easy.
use File::Stream;
my $stream = File::Stream->new(
$filehandle,
separator => qr/\s*,\s*/,
);
print "$_\n" while <$stream>;
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
complete line (using your regular expression).
local $_ = "";
while( sysread FH, $_, 8192, length ) {
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.
local $_ = "";
while( sysread FH, $_, 8192, length ) {
foreach my $record ( m/\G((?s).*?)your_pattern/gc ) {
}
substr( $_, 0, pos ) = "" if pos;
}
Here's a lovely Perlish solution by Larry Rosler. It exploits
properties of bitwise xor on ASCII strings.
$_= "this is a TEsT case";
$old = 'test';
$new = 'success';
s{(\Q$old\E)}
{ uc $new | (uc $1 ^ $1) .
(uc(substr $1, -1) ^ substr $1, -1) x
(length($new) - length $1)
}egi;
print;
And here it is as a subroutine, modeled after the above:
sub preserve_case($$) {
my ($old, $new) = @_;
my $mask = uc $old ^ $old;
uc $new | $mask .
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";
This prints:
this is a SUcCESS case
As an alternative, to keep the case of the replacement word if it is
longer than the original, you can use this code, by Jeff Pinyan:
sub preserve_case {
my ($from, $to) = @_;
my ($lf, $lt) = map length, @_;
if ($lt < $lf) { $from = substr $from, 0, $lt }
else { $from .= substr $to, $lf }
return uc $to | ($from ^ uc $from);
}
This changes the sentence to "this is a SUcCess case."
Just to show that C programmers can write C in any programming language,
if you prefer a more C-like solution, the following script makes the
substitution have the same case, letter by letter, as the original.
(It also happens to run about 240% slower than the Perlish solution runs.)
If the substitution has more characters than the string being substituted,
the case of the last character is used for the rest of the substitution.
sub preserve_case($$)
{
my ($old, $new) = @_;
my ($state) = 0;
my ($i, $oldlen, $newlen, $c) = (0, length($old), length($new));
my ($len) = $oldlen < $newlen ? $oldlen : $newlen;
for ($i = 0; $i < $len; $i++) {
if ($c = substr($old, $i, 1), $c =~ /[\W\d_]/) {
$state = 0;
} elsif (lc $c eq $c) {
substr($new, $i, 1) = lc(substr($new, $i, 1));
$state = 1;
} else {
substr($new, $i, 1) = uc(substr($new, $i, 1));
$state = 2;
}
}
if ($newlen > $oldlen) {
if ($state == 1) {
substr($new, $oldlen) = lc(substr($new, $oldlen));
} elsif ($state == 2) {
substr($new, $oldlen) = uc(substr($new, $oldlen));
}
}
return $new;
}
Put use locale; in your script. The \w character class is taken
from the current locale.
See the perllocale manpage for details.
You can use the POSIX character class syntax /[[:alpha:]]/
documented in the perlre manpage.
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 /[^\W\d_]/. Its complement,
the non-alphabetics, is then everything in \W along with
the digits and the underscore, or /[\W\d_]/.
The Perl parser will expand $variable and @variable references in
regular expressions unless the delimiter is a single quote. Remember,
too, that the right-hand side of a s/// substitution is considered
a double-quoted string (see the perlop manpage 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:
$string = "Placido P. Octopus";
$regex = "P.";
$string =~ s/$regex/Polyp/;
Because . is special in regular expressions, and can match any
single character, the regex P. here has matched the <Pl> in the
original string.
To escape the special meaning of ., we use \Q:
$string = "Placido P. Octopus";
$regex = "P.";
$string =~ s/\Q$regex/Polyp/;
The use of \Q causes the <.> in the regex to be treated as a
regular character, so that P. matches a P followed by a dot.
(contributed by brian d foy)
The /o option for regular expressions (documented in the perlop manpage and
the perlreref manpage) 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.
Since the match operator m//, the substitution operator s///,
and the regular expression quoting operator 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.
This example takes a regular expression from the argument list and
prints the lines of input that match it:
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 $pattern had not changed. The /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;
}
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 /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 /o.
You can watch Perl's regular expression engine at work to verify for
yourself if Perl is recompiling a regular expression. The use re
'debug' pragma (comes with Perl 5.005 and later) shows the details.
With Perls before 5.6, you should see re reporting that its
compiling the regular expression on each iteration. With Perl 5.6 or
later, you should only see 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/;
}
While this actually can be done, it's much harder than you'd think.
For example, this one-liner
perl -0777 -pe 's{/\*.*?\*/}{}gs' foo.c
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,
created by Jeffrey Friedl and later modified by Fred Curtis.
$/ = undef;
$_ = <>;
s#/\*[^*]*\*+([^/*][^*]*\*+)*/|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^/"'\\]*)#defined $2 ? $2 : ""#gse;
print;
This could, of course, be more legibly written with the /x modifier, adding
whitespace and comments. Here it is expanded, courtesy of Fred Curtis.
s{
/\* ## Start of /* ... */ comment
[^*]*\*+ ## Non-* followed by 1-or-more *'s
(
[^/*][^*]*\*+
)* ## 0-or-more things which don't start with /
## but do end with '*'
/ ## End of /* ... */ comment
| ## OR various things which aren't comments:
(
" ## Start of " ... " string
(
\\. ## Escaped char
| ## OR
[^"\\] ## Non "\
)*
" ## End of " ... " string
| ## OR
' ## Start of ' ... ' string
(
\\. ## Escaped char
| ## OR
[^'\\] ## Non '\
)*
' ## End of ' ... ' string
| ## OR
. ## Anything other char
[^/"'\\]* ## Chars which doesn't start a comment, string or escape
)
}{defined $2 ? $2 : ""}gxse;
A slight modification also removes C++ comments, as long as they are | 
