reading the file using the line number

[greatshots]

dear monks,

I have a log file. I am not interested in reading all the lines of a log file. I am only interested in reading a specific lines of a file using line number. For example, If I would like to read only line numbers 6,1003,2965 from the log file, what is the best way I can write a code for this.
right now I am reading the whole file into an array and from the array I read the file.

my @log_file_contents = <FH>;
map { $_ =~ s/[\r\n]//g' } @log_file_contents;
print "$log_file_contents[6]\n";
print "$log_file_contents[1003]\n";
print "$log_file_contents[2965]\n";

Is there any better solution for this ?

[ikegami]

Tie::File is simplest.

tie my @array, 'Tie::File', $file_name
   or die("Unable to open file \"$file_name\": $!\n");

print($array[$_])
   for 6, 1003, 2965;

Tie::File can use a fair bit of memory (for its index, which is above and beyond what the memory argument limits), so you might want to write your own (faster, more memory efficient) solution.

my %lines_of_interest = map { $_ => 1 } 6, 1003, 2965;

open my $fh, '<', $file_name
   or die("Unable to open file \"$file_name\": $!\n");

my $num_lines = keys %lines_of_interest;

while (<$fh>) {
   if ($lines_of_interest{$.}) {
      print;
      last unless --$num_lines;
   }   
}

Update: Added Tie::File code.
Update: Added key counting to exit loop sooner.

[davido]

Keep in mind that because "lines" are of variable length, there is no way to simply jump to line 1000 without first sifting through the file line by line to determine where line 1000 begins in the file. So any solution you come up with (short of maintaining an index or requiring uniform-length lines) will require that the file be read at least once, at least until the proper line number is finally found.

But you don't have to slurp the whole file into an array. It's fine to just read line by line, and take action when the desired line number is found.

[sgt]

actually this problem makes me think of a fairly recent discussion on p5p about the non-linear behaviour of the perl internal unicode implementation in the regex engine

the problem is that to know the line position or the character position (supposing characters don't have all the same size) you have to count from the start...OR...do a bit of preparation, you put "markers" along the way

maybe Tie::File uses something similar but essentially you keep the byte position of the start of every line = 0 modulo k, so to find line n *k +q seek to marker n and read q lines from there

markers can be created as you fetch the lines, o pre-created in one go -- in the case of the regex engine, the algorithm could go both ways depending on the size of the "text" to match, or the maximum backtrack so far

hth --stephan

[GrandFather]

Super Search is your friend. "read file line" in the title for SoPW turns up: Line number in a file, reading a particular line in a large text file, Best way to read line x from a file, Reading Lines from Text file and reading a random line from a file among many many others. This is not an infrequently asked question.

[Fengor]

inspired by tom christiansens oneliners:

perl -ne 'print if $. == $number; exit if $. > $number;'

Edit: corrected typo, thx to davorg

[davorg]

perl -ne 'print if $. = $number; exit if $. > $number;'

You probably want '==', not '=', there.

[tirwhan]

You coulld use Tie::File

use Tie::File;

use strict;
use warnings;

my @log_file_contents;
tie @log_file_contents, 'Tie::File', "filename"
  or die "Can't open filename";
print "$log_file_contents[6]\n";

This does not read the whole file into memory.

[MonkE]

Tie::File seems to be the best solution proposed so far, but bear in mind that it doesn't magically know where line 6000 starts. If you open a file and then ask for line 6000, it will (internally) read from the beginning of file and count to line 6000. However, it does cache line offsets, so if you subsequently ask for line 6050, it will remember the byte offset for line 6000, jump straight to it, and then start counting lines until it reaches line 6050.

If you're interested in learning more, have a look at the line number caching logic in File.pm (in the Tie::File package). It's groovy!

[padma]

You can use the following sub routine to extract particular lines from a file :

sub extract {
   my ($filename, $line_no)=@_;
   my $line;
   open (FILE, $filename) || die "$filename can't be opened $! "
   if ($line_no =~ /\D/) {
        while ($line=<FILE>) {
            if ($line =~ /$line_no/) {
                return $line;
            }
        }
   }
   else {
     foreach (1..$line_no) {
           $line = <FILE>;
        }
        return $line;
   }
}

You have to pass the filename and the line number required. You can pass only one line no. required at a time. This can also be used to obtain a phrase from the file by passing the phrase to the sub routine.

An example:
$file = "example.txt";
$line_no_reqd = 4; 
$result = &imp($file,$line_no_reqd);
print $result;

This example will fetch the contents in line no. 4 from the file, example.txt and print it.

[Fengor]

sub extract {
  (my $filename, my $line_no)=@_;
  open (FILE, $filename) or die "$filename can't be opened: $! ";
  my $line = <FILE>;

  $. = $line_no;
  $line = <FILE> or die "Couldn't read line $line_no: $!";

  return $line;
}