The string: "now is the time for all good monks to come to the aid of their perl". The results:

Benchmark: timing 5000000 iterations of /.*perl/, /^.*perl/, /perl/...
  /.*perl/: 43 secs (41.48 usr  0.00 sys = 41.48 cpu)
 /^.*perl/: 38 secs (36.20 usr  0.00 sys = 36.20 cpu)
    /perl/: 29 secs (28.96 usr  0.00 sys = 28.96 cpu)
[download]

Fastolfe is correct that a straight match will be faster. The /^.*\@/ is forced to match to the end of the string (or to a newline) and then backtrack to the @ symbol. This is extra overhead and will slow it down.

If you use minimal matching with /^.*?\@/, the regex matches every character (except for newline and end-of-string) and then looks ahead for the @ symbol. Again, you have extra overhead.

A simple scan for the @ symbol (/\@/) just looks for the @ symbol and returns true if found. That is the fastest way to scan for the character. See Death to Dot Star! if you wish to understand more about the dot metacharacters in regexes.

Ovid said:

> The /^.*\@/ is forced to match to
> the end of the string (or to a newline) and then backtrack to the @ symbol.

But that is not exactly true. In general, Perl does behave that way. But in some cases, such as this one, there is an optimization: Perl sees that the string can't match unless it contains a @ character, so it looks for the @ first, and works outwards from there. In particular, it does not let .* match all the way to the end of the string and then backtrack it; it gets the right length for .* on the first try.

Isn't that interesting?

The nongreedy .*? version is optimized similarly, so I would be surprised if it performed any differently in this example.

        Rate regexp  index
regexp 826/s     --   -10%
index  921/s    11%     --

with Benchmark. Why throw the regex engine at a single character when there is lovely little function just for that? =)