Also, perlre says: once you've used them once, use them at will, because you've already paid the price. If I read that right, it means that the performance hit is only triggered once, the first time one uses them.

I could make a point here about coding for simplicity instead of (unnecessary) performance, but mainly, I am just curious. Is this advice something that is given as a knee-jerk response, and because we all want to have great performance, or is the impact really so large that it matters in usual cases?

All that aside, I do agree that it is a bad idea to use them in any module that might be used by someone else - there is no telling what the performance considerations might be for that script. If you are using English, performance is probably not what you are looking for. But there are probably other examples.

If I read that right, it means that the performance hit is only triggered once, the first time one uses them.

No. What that means is that once you use them, all matches will incur the overhead of using them whether or not you actually do. It's not a one-time hit but it is all-or-nothing.

(This is my 1000th post! :-)

-sauoq
"My two cents aren't worth a dime.";

Gotcha! I guess it is too late over here to read documentation. :)

But I still wonder how much of a penalty there is.

---

You have moved into a dark place.
It is pitch black. You are likely to be eaten by a grue.

How big is the impact? Better than 10x in a simple test (5.8.0 on Win2K).

Just for fun, here's the benchmark. It took some guesswork to get it to run the subs in the right order - clean first, then use English;, then naughty. If anyone uncomments the print statements to test the order, use 1 as an argument so you don't have to wait forever. Here are the results:

use strict;
use Benchmark qw/cmpthese/;

my $time = shift || -5;
my $text = 'x' x 10_000;
sub clean {
#    print "clean";
    $text =~ m/^x/;
}
sub make_dirty {
#    print "md";
    eval "use English;";
}
sub naughty {
#    print "naughty";
    $text =~ m/^x/;
}
my %hash = ( clean => 'clean',
             naughtify => 'make_dirty',
             sawamp => 'naughty',
           );
cmpthese ( $time, { clean => 'clean',
                    naughtify => 'make_dirty',
                    sawamp => 'naughty',
                  });
__END__
results:
C:\s\pldir>naughty.pl -5
              Rate naughtify    sawamp     clean
naughtify    433/s        --      -98%     -100%
sawamp     24153/s     5481%        --      -92%
clean     300603/s    69366%     1145%        --
[download]

Someone with more benchmark-fu may correct me on this, but it looks right to me.

$string = $';
[download]

You can't do that because the code $money =  '$'.$money if ($currency eq 'USD'); also matches. (Only perl can parse Perl.)

---

Warning: Unless otherwise stated, code is untested. Do not use without understanding. Code is posted in the hopes it is useful, but without warranty. All copyrights are relinquished into the public domain unless otherwise stated. I am not an angel. I am capable of error, and err on a fairly regular basis. If I made a mistake, please let me know (such as by replying to this node).

They no longer invoke the horrible penalty they used to, but in any case I prefer using parentheses to isolate subexpressions I want to remember.

--
TTTATCGGTCGTTATATAGATGTTTGCA

while (<DATA>){
  while ($_ =~/(^|\W)CPAN(\W)/gi){
  print substr($`,length($`)-10) . $& . substr($',0,10) . "\n";
  }
}
__DATA__
To my great surprise, when I traced it out I found two CPAN modules (s
+o far) that we use are also tainted in this way: Printer and Math::Ma
+trixReal.  I have sent mail to the maintainers of these modules point
+ing out the issue.  It makes me wonder how many other CPAN modules ar
+e tainted with "naughty match variables".
[download]

ZAZ@localhost ~
$ perl sample.pl
 found two CPAN modules

many other CPAN modules ar