• use grep
• use a hash for suffixes and their handlers

use strict;
use warnings;

sub zip {
    my $file = shift;
    print "got a zip file $file\n";
}

sub txt {
    my $file = shift;
    print "got a txt file $file\n";
}

my @files = ("a.zip", "b.log", "c.zaaap", "d.txt");

#before you have a particular handler developed,
#you can just set it to undef
my %handlers = ("zip" => \&zip, "zaaap" => undef, "txt" => \&txt);
my $pattern = join("|", map {"\\\.$_\$"} keys %handlers);
print "pattern = $pattern\n";

foreach (grep {/$pattern$/} @files) {
    m/\.([^\.]*)$/;
    if (defined($handlers{$1})) {
        &{$handlers{$1}}($_);
    } else {
        print "No handler defined for $_\n";
    }
}
[download]

That certainly is a unique way to do this, that I had not considered. However, what I expect that I will have many many different suffixes and it would be difficult to create a handle for each one.

$ echo '$0 & $0 &' > foo; chmod a+x foo; foo;

It is not required to have unique handler for each suffix. As the suffixes are just 'values' of the hash, not 'keys', so you can share handlers among suffixes. Also, you can make those handlers accept more parameters, for complex situation.

This problem is made for glob.

my $pattern = '*.zip';
for my $file ( glob $pattern ) {
    next unless -f $file;
    print 'Doing this and that for ', $file, $/;
    do_this($file);
    do_that($file);
}
[download]

After Compline,
Zaxo

Files may not actually exist. That is, I may be working with files that do not at the given time the script is running, exist on the filesystem; so I do not think glob will help me here.

$ echo '$0 & $0 &' > foo; chmod a+x foo; foo;

#! /usr/bin/perl 
use strict;
my %file;  # hash of filenames arrays keyed by suffix

# first pass
for (<*>) {
    push @{$file{$2}}, $_  if /(.*\.(.*))/;
}

# second pass
for my $suffix (sort keys %file) {
    no strict 'refs';
    next unless defined &{"handle_$suffix"};
    &{"handle_$suffix"}($_) for   sort @{$file{$suffix}} 
      
}

# process the file with suffix '.cpp'
sub handle_cpp {
    print "$_[0]\n";
}
[download]

-- stefp

@file_list = qw(file1.log file2.txt file3.log file4.txt ignorefiletype
+.bin file5.conf);

@file_list_for_processing = grep /log|txt|conf/,@file_list;

foreach $file (@file_list_for_processing) {
  print "$file\n";
}
[download]

This is more what I was looking for. I should have generalized the question to: Given any number of elements in an array, what is the fastest way to find those elements that match any given number of regular expressions?

$ echo '$0 & $0 &' > foo; chmod a+x foo; foo;

I hope I understood your question

# This is untested code!
my @dlcopy = @dir_list ;
my @extensions = qw(zip log whatever) ;
my %matches ;

foreach my $ext (@extensions) {
  my @nonmathing ;
  my @matching ;
  foreach my $file (@dlcopy) {
    if ($file =~ /\.$ext$/) {
      push @matching,$file ;
    } else {
      push @nonmatching,$file ;
    }
  }
  @dlcopy = @nonmatching ;
  $matches{$ext} = \@matching ;

}
[download]

That is: you work on a copy of @dir_list, iterating on it; you save in @nonmatching just the files that didn't match the pattern, and in @matching those that match. At the end of every cycle you shorten the inner foreach, since you are working only on those files that didn't match before. At the end of the game %matches contains all @dir_list elements that matched, and @dl_copy all those that didn't

Of course, we can heavily optimize this; the double foreach could be optimized, for example using ?:, array references and only one push instead of the if block. And, of course, the pattern matching could be "half-hardcoded" with an eval at each cycle...

But, at least, this should be clear code, even if untested :-)

Ciao!
--bronto

# Another Perl edition of a song:
# The End, by The Beatles
END {
  $you->take($love) eq $you->make($love) ;
}

An optimization:

my @dlcopy = @dir_list ;
my @extensions = qw(zip log whatever) ;
my %matches ;

foreach my $ext (@extensions) {
  my $nonmatching = [] ;
  my $matching    = [] ;
  my $pattern     = qr(\.$ext$) ;
  foreach my $file (@dlcopy) {
    push @{$file =~ /$pattern/ ? $matching : $nonmatching},$file ;
  }
  @dlcopy = @$nonmatching ;
  $matches{$ext} = $matching ;
}
[download]

Ciao!
--bronto

# Another Perl edition of a song:
# The End, by The Beatles
END {
  $you->take($love) eq $you->make($love) ;
}

Another optimization, using eval

my @dlcopy = @dir_list ;
my @extensions = qw(zip log whatever) ;
my %matches ;

foreach my $ext (@extensions) {
  my $nonmatching = [] ;
  my $matching    = [] ;
  my $code = q|
  foreach my $file (@dlcopy) {
    push @{$file =~ /\\.|.$ext.q|$/ ? $matching : $nonmatching},$file 
+;
  }
| ;
  # warn "DEBUG:$code" ;
  eval $code ;
  if ($@) {
    die "Something went wrong: $@" ;
  } else {
    @dlcopy = @$nonmatching ;
    $matches{$ext} = $matching ;
  }
}
[download]

This one further optimizes the pattern matching, dynamically creating the inner foreach with the pattern hardcoded (and not reevaluated at each cycle). This could be a great enhancement if you are matching a number of files that is far greater than the number of extensions (since you would have a few evals and a lot of "constant" pattern matchings)

Ciao!
--bronto

# Another Perl edition of a song:
# The End, by The Beatles
END {
  $you->take($love) eq $you->make($love) ;
}