Adapting my reply to Reading files n lines a time illustrates another approach:

use strict;
use warnings;

my $fname = shift or die "usage: $0 fname\n";
open(my $fh, '<', $fname) or die "error: open '$fname': $!";

my $chunksize = 2;
my $chunk = "";
while ( my $line = <$fh> ) {
    $chunk .= $line;
    next if $. % $chunksize;
    print "---chunk---\n$chunk";
    $chunk = "";
}
close $fh;
if (length $chunk) {
    print "---chunk (leftover)---\n$chunk";
}
[download]

Sample output with two simple test files, one with four lines:

---chunk---
one
two
---chunk---
three
four
[download]

and one with five lines:

---chunk---
one
two
---chunk---
three
four
---chunk (leftover)---
five
[download]

For your use-case you would obviously do something different to my crude printing of chunks above.

Some Similar PM Nodes

• Reading two lines per loop iteration
• Reading files n lines a time
• Split string after 14 Line Feeds? -- with an interesting reply from the LanX I see :)

Instead of looking at the next line, consider looking at the last line and the current line:

my $lastline;
while (my $currentline = <$fh>) {
    chomp $currentline;
    my @tmp = split /\s+/, $row;
    ...
    $lastline = $currentline;
}
[download]

Alternatively, you can look at accessing the file as an array, using Tie::File.

If you're dealing with CSV data, consider using Text::CSV_XS.

The sliding window concept is a generic way to solve such "n'th line before" , "x'th line after" requirements.

See Re^2: Grab 3 lines before and 2 after each regex hit (sliding window) and especially the code in the "update".

NB the window size in your example is just 2 then.

I try to avoid stuff like $tmp[0] because you need a comment to describe what the heck the 0th field actually means! I used an array slice to move the indexing into the split so that I could assign this first column a scalar name. You should use terminology appropriate for your application. I didn't see the need for chomp, only to add a "\n" back in. The split will remove any \n if there is just one token on the line. Also, I personally wouldn't put multiple statements on the same line. Perl doesn't care, but people do.

I would do something different if this involved reading chunks of more than 2 lines. But this specific case, I find the below adequate.

use strict;
use warnings;

my $cnt=1;

while (defined (my $first = <DATA>) and defined (my $second = <DATA>) 
+) 
{
   
   my $name1 = (split /\s+/, $first)[0]  // last;  # handle trailing
   my $name2 = (split /\s+/, $second)[0] // last;  # potential "\n" bl
+ank lines
   
   print "$cnt\t$first";
   
   if ($name1 ne $name2) 
   { 
      $cnt++; 
   }

   print "$cnt\t$second";
}

=prints
1       one
1       one
1       two
1       two
1       three
1       three
1       three
2       four
note: same result with or without the trailing blank line
=cut


__DATA__
one
one
two
two
three
three
three
four
Odd line here followed by a blank line if you want
[download]

Here's two creative ways - slurp the whole file, then use regex lookahead to get the "next" line, or use tell() and seek() to read ahead then reset the current file position.

#!/usr/bin/perl

use strict; # https://perlmonks.org/?node_id=11135401
use warnings;

open my $fh, '<', \<<END or die;
line one
line two
line three
line four
line five
END

{
local $/;
local $_ = <$fh>;
while( /^(.*)\n(?=(.*))/gm )
  {
  print "$1 -> $2\n";
  }
}

print "\n";
seek $fh, 0, 0; # reset for different example

while( <$fh> )
  {
  chomp;
  my $pos = tell $fh;
  print"$_ -> ", (<$fh> // "AT LAST LINE\n");
  seek $fh, $pos, 0;
  }
[download]

Outputs:

line one -> line two
line two -> line three
line three -> line four
line four -> line five
line five -> 

line one -> line two
line two -> line three
line three -> line four
line four -> line five
line five -> AT LAST LINE
[download]

#!/usr/bin/perl

## Go through a stream and prints all but the last n lines where n is 
+a command line argument:

my @cache;
my $n = shift @ARGV;

while(<>) {
    push @cache, $_;
    print shift @cache if @cache > $n;
}
[download]