> Will a regex of the form .*c ever match differently 
> from [^c]*c, and if not, why doesn't the regex parser 
> optimize it to the later form? What if the first was .*?c
[download]

1. m/(.*c)/ && print $1;
2. m/([^c]*c)/ && print $1;
3. m/(.*?c)/ && print $1;
[download]

How they match is also different. 1 will match everything until the end of the string, then backtrack, one character at a time, until the last character in the match is a "c" (a summarized explanation). 2 will only gobble up until it finds a c, because the c won't satisfy [^c]; then it matches the c. No backtracking. The non-greedy version (3) will match zero characters, and then look for a c; then match 1 character, and then look for a c; then match match 2 characters, and look for a c; and so on.

This difference in how the matching is done has a big influence on performance. Since .* will always gobble up the whole string, and then backtrack, if you have a Really Long String which starts with "abc", it'll take a Really Long Time (relatively) for pattern 1 to match, compared to pattern 2 or pattern 3.

As for your first question... I'm not entirely sure why it's not working. I'll try it out and update if I come up with anything.

Alan

Update: I'm not willing to say that Under All Circumstances, patterns 2 and 3 above will match the same thing. I can't think of a counterexample off the top of my head, but that doesn't mean one doesn't exist. I'm also not willing to say that one is faster than the other without benchmarking. For all I Really Know, they could match the same thing, and perl could already be optimizing one into the other for the sake of performance. But, you're right, it does certainly look like they'll both always match the same thing. Not necessarily, if part of a larger regex, though.

> m/([^c]*c)/ will only gobble up until it finds a c, because the c won't
> satisfy ^c; then it matches the c. No backtracking. The non-greedy version (m/(.*?c)/) will
> match zero characters, and then look for a c; then match 1 character, and then look
> for a c; then match match 2 characters, and look for a c; and so on.

This seems to indicate that m/(.*?c)/ and m/([^c]*c)/ will always match the same strings, but the first will be far fatster (in _all_ cases, that I can see at least). So why isn't the first optimized into the second?

I'm probably not seeing somthing here.

Thanks,
James Mastros,
Just Another Perl Initate

m/(.*?c)/ will not match newline if the /s modifier is not used.

I don't think that '.' matches a "\n" by default. One difference at least.

Well, not all file names have extensions, so you might want one of these:

( $base, $ext )= $file =~ /^(.*?)([.][^.]*)?$/s;

$ext= ( $base= $file ) =~ s/([.][^.]*)$// ? $1 : "";

$base= substr( $ext= $file, 0,
  0xffff & rindex($file,"."), "" );
[download]

/.*?c/s and /[^c]*c/ will always (I'm pretty sure) match the same thing (note the addition of "s" to the first one) as they stand. But you were using these as part of a larger regex, and there they don't always match the same thing. For example, /.*?cd/s and /[^c]*cd/ (adding a "d" to each one) don't always match the same things. On the string "abcabcd", the first will match "abcabcd" while the second will only match "abcd".

Ah, thank you (for your second point); that finaly clears it up. (All the other answers didn't parse the question as I meant it.)

As for the second part, since all these files have a name of the form a-z+-0-9+a-z0-9-*.jpg, so I just used a simple split /\./. (They're all jpegs now, but that might change; I wanted it to be at least a little more generic.) Your point is, of course, well taken, though there's probably a large problem space where you do know that there is an extention.

Thanks also to all the other people that had solutions to the $id.$ext problem as well; your answers were almost all enlightening.

I still wonder which is more efficent. I'll probably do some benchmarking at some later point.

Thanks,
James Mastros,
Just Another Perlmonks Neonate

@dissection = split /\./, $filename;
$ext = pop(@dissection);
$id = join(".",@dissection);
[download]

While we are doing high level manipulations, you can also do:

($name,$ext) = reverse map {scalar reverse} (split /\./, (reverse $fil
+ename), 2);
[download]

Ciao,
Gryn

Or:

my( $name, $ext );
{
  my @chunks = split/\./, $filename; 
  $ext = pop @chunks;
  $name = join '.', @chunks;
}
[download]

If you don't like reverse for some reason.

Actually I really liked gryng's answer... I was just trying to thing of another way to do it using split.

For them that like one-liners:

my( $ext, $name )=(@_=split/\./, $filename and pop @_, join '.', @_);
[download]

/(.*)\.([^\.]+)/

gryng wrote:

I'm not very good at regex's theorbtwo, so instead of saying
something vague and probably wrong, I'm just going to offer up real
quick the regex I'd use (and hope it works):
/(.*)\.([^\.]+)/

The funny thing is, I just learned this afternoon that you don't need to escape the dot in a character class: so the above is wrong. Assuming that you meant (obviously you did) what you typed. dot is just dot inside the brackets. (Camel 2cd Ed page 71, in the middle of the code in the page).

Intrepid

I sold my Camels to afford thinkgeek.com's perl book set, and then it went to back order :( . So I'm Camel-less and can't use your nifty reference :( :( . However I do believe you, but I think my code still works it's just I didn't need to escape when I did. Thank you though :) .... :( but I'm still sad about my missing Camels :(

Gnight,
Gryn

Thanks,
James Mastros,
Just Another Perl Initate

$filename =~ /(.*?)\.(.*?)$/;
$id = $1;
$ext = $2;
[download]

.*? means match the smallest number -- a non-greedy match. Whereas .* means match the largest number -- a greedy match. Changing the * to a + only changes the minimum match amount (0 to 1). As a side note you can say .{0,} as the equivalent to * and {1,} as + (and, for example, .{3,5} would match 3 to 5 characters).

Gnight,
Gryn

use File::Basename
$basename = basename($filename);
[download]

I was just going to write that... I use File::Basename all the time for filename splitting. Hasn't failed me yet and heres how you do your bit.

use strict;
use File::Basename;

my $file = '/ftp/dest/id.ext';

my ($name, $path, $suffix);

my @suffixes = ('.ext'); # Extra extensions can be added to the list.

($name, $path, $suffix) = fileparse($file, @suffixes);
[download]

Coffee, KitKat, and a new script to write. It's gonna be a good day....

Ah, beutiful. I saw File::Spec (and use it), but I missed File::Basename.

Thanks,
James Mastros,
Just Another Perl Initate

Question 2) I decline to answer on the grounds that I might incriminate myself.

/^(.*?)\.(\w+)$/;
[download]

/****************************/
  jason@gost.net, wh@ckz.org
    http://jason.gost.net
/*****************************/
[download]

As for the first question (posted over a year ago... whew), this is a pretty easy way to do it: $file = $filename; $ext = $filename; $file =~ s/.+\\(^\\+)$|.+\/(^\/+)$/$1/; $ext =~ s/\.(\w+)$/$1/; That should give you the file's name in $file and it's extension in, well, $ext. ;) - Dave Baughman