for my $file (@test_files) {
  # use $file here
  while (<TEST_FILE>) {
    # use $_ here
  }
}
[download]

Update: Your example does illustrate the difference between for loops and while loops. In the following nested loops, $_ does not get clobbered:

for (1..3) {
  print "_ before = $_\n";
  for ('a'..'c') {
    print "_ inner loop = $_\n";
  }
  print "_ after = $_\n"; # prints same as before inner loop
}
[download]

It's actually quite simple: the diamond operator (in your example, "<TEST_FILE>" is the diamond operator with the filehandle TEST_FILE as its argument) reads one line from the filehandle supplied and puts it in $_, clobbering whatever was there. A bare "print;" then uses the implied $_ variable as its argument.

I see two options: either localize $_ by using "local $_;" in a scope outside your while loop but within your foreach loop, or use a lexical variable in your outer scope (e.g. "foreach my $file (@test_files)") and then substitute it for $_ in your outer loop. In my opinion the latter is much clearer and thus preferred.

I could also have suggested a replacement for the automatic use of $_ in the inner loop, but the benefits you gain from using the implied $_ variable here are greater than those you lose by not using it in your outer loop.

foreach (@blah) {
   do stuff with $_ from @blah
   {
      my $_;
      while (<HANDLE>) {
         do stuff with $_ read from the handle
      }
   }
   do stuff with $_ from @blah
}
[download]

Note too that the 3 argument version of open is safer and clearer than the two argument version in your sample code:

open TEST_FILE, '<', $_ or die ...
[download]

Perhaps also of interest is that the while print loop can be rewritten:

print while <TEST_FILE>;
[download]

or even:

print <TEST_FILE>;
[download]

although I presume you have provided sample code and such trivial stuff doesn't apply in your real application.

For various reasons rewriting your for loop header as:

for my $filename (@test_files) {
[download]

is a good thing to do. The immediate reason is that it fixes your problem (as others have mentioned already). It also better documents your code and may facilitate debugging it. You do of course need to use $filename in place of $_ as appropriate.

Ah, I see. Thanks. Can you explain the philosophy behind this design choice? That is, does localizing $_ in for loops, but not in while loops, provide something useful to Perl? Thanks. -db

Localizing $_ in a while loop would cause any changes to that variable to mysteriously be lost when you exit the while.

Code should not mess around with things that are not its concern, since that would generate unintended and unexpected side effects. The while loop does not inherently use $_, so therefore it should not localize or otherwise muck up $_.

The same reasoning would explain why a while loop does not automatically localize @test_files as well.

Because $_ has nothing to do with while loops. You're looking at one specific while loop (while (defined($_ = <FILE>)) when asking that question, but while is used in many other ways too. For example, why should Perl localize $_ in while (@todo)? Or in while (my ($key, $val) = each %hash)?

larry he is not