A glob evaluates its (embedded) argument only when it is
       starting a new list.  All values must be read before it
       will start over.  In a list context this isn't important,
       because you automatically get them all anyway.  In scalar
       context, however, the operator returns the next value each
       time it is called, or a undef value if you've just run
       out. As for filehandles an automatic defined is generated
       when the glob occurs in the test part of a while or for -
       because legal glob returns (e.g. a file called 0) would
       otherwise terminate the loop.  Again, undef is returned
       only once.  So if you're expecting a single value from a
       glob, it is much better to say
 
           ($file) = <blurch*>;
 
       than
 
           $file = <blurch*>;
 
       because the latter will alternate between returning a
       filename and returning FALSE.
[download]

If you use the doc's suggested solution your problem should disappear!

Chipmonk,

Thank you. I can't figure out how I missed that in perlop, as I did spend some time trying to figure this out before posting.

As for how to do this better (i.e., so it works), I posted a follow up to my node on Friday that indicated that I was more comfortable doing this in a list context anyway. That is, get all of the matching files before going into the loop and then using foreach to go through each of them.

Thanks again,
Scott

my $EXON_IN;
for my $i (0..4){
    # Cycle through all of them (including the undef)
    while (<$i/*test.txt>) {
     $EXON_IN = <$i/*test.txt>;
    }
    #OR put in list context
    ($EXON_IN) = <$i/*test.txt>;
    print "$i, -$EXON_IN-\n";
}
[download]

This would skip the odd glob behavior, and also get around some other glob() limitations you might hit later. ( like "too many args").

Here's my shot at converting your short example:

for (my $i=0; $i < 5; $i++){
    opendir(DIR,$i) or die();
    foreach my $file (readdir(DIR)) {
        # if the filename ends in "test.txt"...
        # adjust the regex as needed
        if ($file =~ /test\.txt$/) {
            print "$i, -${file}-\n";
        }
    }
    closedir(DIR);
}
[download]

As far as which one is faster, using the short example, readdir() is at least twice as fast on perl 5.6.0 and hundreds of times faster on perl 5.5.003 ( where glob() still calls out to csh). Here's what I tried, after making a few test directories and files:

use Benchmark;
timethese(10000, {
    'readdir' => sub {
        my @blah;
        for (my $i=0; $i < 5; $i++){
            opendir(DIR,$i) or die();
            foreach my $file (readdir(DIR)) {
                if ($file =~ /test.txt$/) {
                    push(@blah,$file); 
                }
            }
            closedir(DIR);
        }
    },
    'glob' => sub { 
         my @blah;
         for (my $i=0; $i < 5; $i++){
             for (<$i/*test.txt>) {
                 push(@blah,$_);
             }
         }
 
    }
}
);

Results on my perl 5.6.x box:

Benchmark: timing 10000 iterations of glob, readdir...
      glob: 12 wallclock secs ( 
         3.24 usr +  2.22 sys =  5.46 CPU) 
             @ 1831.50/s (n=10000)
   readdir:  3 wallclock secs ( 
        1.54 usr +  1.69 sys =  3.23 CPU)
             @ 3095.98/s (n=10000)

on a 5.005_003 box (1000 iterations, because it's so slow):

Benchmark: timing 1000 iterations of glob, readdir...
      glob: 216 wallclock secs 
            ( 1.83 usr  9.21 sys + 
            63.22 cusr 107.38 csys =  0.00 CPU)
   readdir:  1 wallclock secs ( 
             0.43 usr +  0.37 sys =  0.80 CPU)
[download]

kschwab,

I was under the impression that glob worked in this way now anyway, as opposed to the old way using the shell. If it does work the way I think, the "too many args" thing should be a thing of the past, no? And if that is true, it seems like it might be faster to get all of the files with one glob, and then loop through them.

Thanks,
Scott