Recipe 8.8. Reading a Particular Line in a File
Author: Tom Christiansen & Nathan Torkington
Date: 1999-07-02T01:38:44Z

#

| Chapter 8 File Contents |

## 8.8. Reading a Particular Line in a File

### Problem

You want to extract a single line from a file.

### Solution

The simplest solution is to read the lines until you get to the one you want:

    # looking for line number $DESIRED_LINE_NUMBER
    $. = 0;
    do { $LINE = <HANDLE> } until $. == $DESIRED_LINE_NUMBER || eof;

If you are going to be doing this a lot and the file fits into memory, read the file into an array:

    @lines = <HANDLE>;
    $LINE = $lines[$DESIRED_LINE_NUMBER];

If you will be retrieving lines by number often and the file doesn't fit into memory, build a byte-address index to let you `seek` directly to the start of the line:

    # usage: build_index(*DATA_HANDLE, *INDEX_HANDLE)
    sub build_index {
        my $data_file  = shift;
        my $index_file = shift;
        my $offset     = 0;

        while (<$data_file>) {
            print $index_file pack("N", $offset);
            $offset = tell($data_file);
        }
    }

    # usage: line_with_index(*DATA_HANDLE, *INDEX_HANDLE, $LINE_NUMBER)
    # returns line or undef if LINE_NUMBER was out of range
    sub line_with_index {
        my $data_file   = shift;
        my $index_file  = shift;
        my $line_number = shift;

        my $size;               # size of an index entry
        my $i_offset;           # offset into the index of the entry
        my $entry;              # index entry
        my $d_offset;           # offset into the data file

        $size = length(pack("N", 0));
        $i_offset = $size * ($line_number-1);
        seek($index_file, $i_offset, 0) or return;
        read($index_file, $entry, $size);
        $d_offset = unpack("N", $entry);
        seek($data_file, $d_offset, 0);
        return scalar(<$data_file>);
    }

    # usage:
    open(FILE, "< $file")         or die "Can't open $file for reading: $!\n";
    open(INDEX, "+>$file.idx")
            or die "Can't open $file.idx for read/write: $!\n";
    build_index(*FILE, *INDEX);
    $line = line_with_index(*FILE, *INDEX, $seeking);

If you have the DB_File module, its `DB_RECNO` access method ties an array to a file, one line per array element:

    use DB_File;
    use Fcntl;

    $tie = tie(@lines, $FILE, "DB_File", O_RDWR, 0666, $DB_RECNO) or die
        "Cannot open file $FILE: $!\n";
    # extract it
    $line = $lines[$sought-1];

### Discussion

Each strategy has different features, useful in different circumstances. The linear access approach is easy to write and best for short files. The index method gives quick two-step lookup, but requires that the index be pre-built, so it is best when the file being indexed doesn't change often compared to the number of lookups. The DB_File mechanism has some initial overhead, but subsequent accesses are much faster than with linear access, so use it for long files that are accessed more than once and are accessed out of order.

It is important to know whether you're counting lines from 0 or 1. The `$.` variable is 1 after the first line is read, so count from 1 when using linear access. The index mechanism uses lots of offsets, so count from 0. DB_File treats the file's records as an array indexed from 0, so count lines from 0.

Here are three different implementations of the same program, print_line. The program takes two arguments, a filename, and a line number to extract.

The version in Example 8.1 simply reads lines until it finds the one it's looking for.

#### Example 8.1: print_line-v1

    #!/usr/bin/perl -w
    # print_line-v1 - linear style

    @ARGV == 2 or die "usage: print_line FILENAME LINE_NUMBER\n";

    ($filename, $line_number) = @ARGV;
    open(INFILE, "< $filename") or die "Can't open $filename for reading: $!\n";
    while (<INFILE>) {
        $line = $_;
        last if $. == $line_number;
    }
    if ($. != $line_number) {
        die "Didn't find line $line_number in $filename\n";
    }
    print;

The index version in Example 8.2 must build an index. For many lookups, you could build the index once and then use it for all subsequent lookups:

#### Example 8.2: print_line-v2

    #!/usr/bin/perl -w
    # print_line-v2 - index style
    # build_index and line_with_index from above
    @ARGV == 2 or
        die "usage: print_line FILENAME LINE_NUMBER";

    ($filename, $line_number) = @ARGV;
    open(ORIG, "< $filename")
            or die "Can't open $filename for reading: $!";

    # open the index and build it if necessary
    # there's a race condition here: two copies of this
    # program can notice there's no index for the file and
    # try to build one.  This would be easily solved with
    # locking
    $indexname = "$filename.index";
    sysopen(IDX, $indexname, O_CREAT|O_RDWR)
             or die "Can't open $indexname for read/write: $!";
    build_index(*ORIG, *IDX) if -z $indexname;  # XXX: race unless lock

    $line = line_with_index(*ORIG, *IDX, $line_number);
    die "Didn't find line $line_number in $filename" unless defined $line;
    print $line;

The DB_File version in Example 8.3 is indistinguishable from magic.

#### Example 8.3: print_line-v3

    #!/usr/bin/perl -w
    # print_line-v3 - DB_File style
    use DB_File;
    use Fcntl;

    @ARGV == 2 or
        die "usage: print_line FILENAME LINE_NUMBER\n";

    ($filename, $line_number) = @ARGV;
    $tie = tie(@lines, "DB_File", $filename, O_RDWR, 0666, $DB_RECNO)
            or die "Cannot open file $filename: $!\n";

    unless ($line_number < $tie->length) {
        die "Didn't find line $line_number in $filename\n"
    }

    print $lines[$line_number-1];                        # easy, eh?

### See Also

The documentation for the standard DB_File module (also in Chapter 7 of Programming Perl ); the `tie` function in perlfunc (1) and in Chapter 3 of Programming Perl; the entry on `$.` in perlvar (1) and in the "Special Variables" section of Chatper 2 of Programming Perl

8.7. Randomizing All Lines |  | 8.9. Processing Variable-Length Text Fields