use File::Basename;

my @files = ("one.zip","twotwo.doc","three3.ppt");
my @onlyNames;
my @onlyExt;

foreach my $file (@files)
{
    my ($name, $path, $suffix) = fileparse( $file, qr/\.[^.]+$/ );
    $suffix =~ s/\.//;
    push @onlyNames, $name;
    push @onlyExt, $suffix;
}
[download]

Update: Fixed typo. (Thanks, Not_a_Number!)

I applaud your use of a prepackaged module, but I personally think it's a bit overkill in this situation.

  my @files = qw( foo.zip twotwo.doc three.one.four.ppt four );
  my ( @only_names, @only_exts );
  foreach ( @files )
  {
      if ( m/^ (.*?) (?:\.([^.]+))? $/x )
      {
          push @only_names, $1;
          push @only_exts,  $2; # might be undef
      }
      else
      {
          warn "couldn't parse '$!'";
      }
  }

  # only for debugging output
  foreach ( @only_exts ) { $_ = 'undef' unless defined $_ }

  print "names = [ @only_names ]\n",
        "exts  = [ @only_exts ]\n";
[download]

Which produced:

  names = [ foo twotwo three.one.four four ]
  exts  = [ zip doc ppt undef ]
[download]

I guess I feel that, since your solution even with a standard module also requires crafting a regex, I'd just as soon write a regex for the whole thing. *shrug*

My main concerns with my solution would be whether the regex is efficient enough — the non-greedy filename part worries me a bit — and the usual "well, you might be able to craft such a regex, but the average programmer..." complaints.

The point here isn't that either solution would require a regex or not. The goal is to teach someone that the issues one generally runs into have been run into many times before. There is often a wheel that's round enough out there.

------
We are the carpenters and bricklayers of the Information Age.

Then there are Damian modules.... *sigh* ... that's not about being less-lazy -- that's about being on some really good drugs -- you know, there is no spoon. - flyingmoose

#!perl -wl

use strict;

my (@f, @e, %f, %e);

map {
        $f{$1} = $e{$2} = !undef if /(.*)\.(.*)/
} glob("*");

@f = keys %f;
@e = keys %e;

print "filenames: @f";
print "extensions: @e";
[download]

my @files = qw(
    one.zip
    twotwo.doc
    three3.ppt
);

my (@only_names, @only_ext);

for (@files) {
    my ($name, $ext) = $_ =~ m!\A(.*)\.([^.]+)\z!s;

    push( @only_names, $name );
    push( @only_ext,   $ext  );
}
[download]

This fails if the file has no extension. Probably a simple test for a match failure would fix this:

    my($name,$ext);
    ($name, $ext) = m!\A(.*)\.([^.]+)\z!s
          or $name = $_,$ext='';
[download]

Q1: If i only want to get the name. Is the following code correct.
Replace

my ($name, $ext) = $_ =~ m!\A(.*)\.([^.]+)\z!s;
[download]

with

my ($name) = $_ =~ m!\A(.*)\z!s;
[download]



Q2: Could you please explain this line

 ($name, $ext) = $_ =~ m!\A(.*)\.([^.]+)\z!s;
[download]

Not in detail , i just want some idea.
I am really impressed with the way i got a reply. it was very quick.

jdporter - added code formatting

my %h = map /(.*)\.(.*)/, @files;
@onlyNames = keys %h;
@onlyExt = @h{@onlyNames};
[download]

@files = ("one.zip","twotwo.doc","three3.ppt");
map {$_ =~ /(.*)\./; push (@onlyNames, $1); push (@onlyExt, $');} @fil
+es;
[download]

The above fails if there's no extension too.

This works:

@files = ("one.zip","twotwo.doc","three3.ppt","testfour");
map {$_ =~ /([^.]*)\.?/; push (@onlyNames, $1); push (@onlyExt, $');} 
+@files;
[download]

This works:

@files = ("one.zip","twotwo.doc","three3.ppt","testfour");
map {$_ =~ /([^.]*)\.?/; push (@onlyNames, $1); push (@onlyExt, $');} 
+@files;
[download]

No, it doesn't always work. It fails if the filename is part of a complete path.

Consider the following input, which will cause a complete path instead of a filename to be pushed into your @onlyNames array:

/usr/bin/perl
/home/users/d/davido/text.txt
C:\Perl\scripts\mytest.pl
[download]

In each of those cases, you'll capture into @onlyNames the following:

/usr/bin/perl
/home/users/d/davido/text
C:\Perl\scripts\mytest
[download]

It gets even worse if one of the directory names in the path contains a dot (.)

Consider what happens if the input looks like this:

C:\Perl\scripts.old\mytest.pl
[download]

In that case, @onlyNames will contain:

C:\Perl\scripts
[download]

And clearly that's not a filename.

Update: Just thought of another situation that may reveal a bug: What if the filename has multiple extensions? In this case, it would be up to the OP to define what constitutes an extension, and what constitutes a filename. But by way of example, your solution would turn:

bigfile.tar.gz
[download]

...into...

bigfile
[download]

The danger here is that while .gz represents the extension, .tar represents a second layer of 'extension'. But the name of the .gz file really is bigfile.tar, since we're dealing with multiple layers of processing on the said file.




Dave