for takes a list, so it reads the entire file before iterating the loop. So, by the time you get to printing the lines within the loop, $. is set to the line number of the last line in the file. Using while instead of for will ensure that you process the file line by line.

BrowserUK is exactly right. The foreach() loop asks for a list. The <> diamond operator behaves differently in list context than it does in scalar context. In scalar context, each time the diamond operator is evaluated it hands you the next line of the file. In list context, the entire file is slurped into memory at once and a list is created (and enumerated for the foreach loop).

The $. special variable tells you what line of a file you most recently read. The foreach loop only evaluates the <> operator one time -- when it slurps in the entire file. Each time through the loop the foreach operator hands you the next line of the list, but the entire file has already been read into memory, and the $. variable tells you this by telling you that you're on line 4.

This is a valuable lesson on how to quietly build a piece of code that cannot scale well when file sizes grow. If it weren't for the fact that the $. variable did something you didn't anticipate, you might have left the foreach loop in your code. Then one day when the file is 2GB huge, your client would call and ask why the program is locking up his system.

Sticking to the while() construct will eliminate that issue.




Dave

    This is equivalent to while(<>) { ... }

use strict;
use warnings;

open my $fh, "test.txt" or die $!;

foreach (;<$fh>;){
    print " $. :$_ \n";
}
[download]

Very interesting. I tried your code, and you are right. $. contains the current line number for each record in the input file. My question is "Why does the presence of semi-colons around the diamond make this work? Do they force scalar mode instead of list mode? Does this mean the file is NOT slurped into a list all at once?

"Its not how hard you work, its how much you get done."

In the C-style for-loop

foreach (;<$fh>;) {
    print " $. :$_ \n";
    }
[download]

the initialization and finalization clauses of the loop (the parts before the first semicolon and after the second semicolon, respectively) are empty. The only clause specified is the conditional clause (between the two semicolons). When the  <> or readline operator is evaluated in the scalar context of the conditional, it returns a single line at a time until the file is exhausted, when it returns undef.

This is equivalent to reading  <$fh> in a while-loop.

Well, this is indeed a for loop

foreach:

First it will fetch all the data from the file and store it into the buffer, then from the buffer only it will print the data. So while storing the buffer it self line number($.) getting incremented. So finally it will have last line number only. So while printing it will print last line number.

Instead of foreach you can use while it will print correct line number.

use strict;
use warnings;
my @a=(1,2,3,4,5);
foreach (@a)
{
    print $_;
}
[download]

The foreach will accept a list so that the foreach expands as follows.

foreach (1,2,3,4,5);
[download]

Similar to that while reading the file contents, it will read the whole file content and $. will set to the last line number.

open my $fh, "test.txt" or die $!;
while(<$fh>) {
   print "$.:$_";
}
__END__
outputs:
1:First line
2:Second line
3:Third line
4:Fourth line
[download]

I know while loop will work. But I wanted why it is behaving differently with foreach.