The +>> mode puts the file position initially at eof, so there is nothing left to read. Your @lines will be empty. (And hence, $lines[-1] etc will be undefined.)

If I read your intentions correctly, you seem to be missing just a seek DAT, 0, 0 before you read from the file. (See seek; in short it sets file position to start of file.)

(The file position will be advanced as you read, so ending up at eof afterwards, but even if it wasn't, opening with +>> makes sure Perl will seek to eof before starting to output anything on the handle.)

I hope this is useful.

Cheers,

JohnGG

If the file is large you might not get great performance so YMMV.

That's probably not going to be much of an issue as (quoth the manual)

     The file is not loaded into memory, so this will work even for gigantic files.

I don't know if Tie::File seeks from the end for large/negative indexes, but it's surely possible for it to do so.

I just read the code... please ignore.

-David

The code (file locking is omitted intentionally):

#!/usr/bin/perl

use strict;
use warnings;

my($rdwr_file, $tie_file) = @ARGV;

with_rdwr();
with_tiefile();

sub with_rdwr {
    open DAT, "+<$rdwr_file" or die "can't open $rdwr_file: $!\n";
    my $last = (<DAT>)[-1];
    if ($last =~ /(\d+)/) {
        my $new = $1 + 1;
        seek DAT, 0, 2 or die "Can't seek in $rdwr_file: $!\n";
        print DAT $new, "\n";
        print "new value for $rdwr_file: $new\n";
    }
    close DAT;
}

sub with_tiefile {
    use Tie::File;
    my @lines;
    tie @lines, 'Tie::File', $tie_file or die "can't tie $tie_file: $!
+\n";
    my $last = $lines[-1];
    if ($last =~ /(\d+)/) { # sure, testing on $lines[-1] saves a line
        my $new = $1 + 1;
        push @lines, $new;
        print "new value for $tie_file: $new\n";
    }
    untie @lines;

}
[download]

The run:

$ echo 0 > rdwr
$ echo 0 > tie
$ cat rdwr
0
$ cat tie
0
$ perl prog.pl rdwr tie
new value for rdwr: 1
new value for tie: 1
$ cat rdwr
0
1
$ cat tie
0
1
... and some executions later..
$ cat rdwr
0
1
2
3
4
5
$ cat tie
0
1
2
3
4
5
[download]

open (DAT, "+>>$file") or die "$!";
[download]

  DB<1> open $fh, '+>>', 'test.dat'                                   
+                                                                     
+           
  DB<2> if ( eof $fh ) { print "Don't try to read, you're at the end!\
+n" }                                                                 
+           
Don't try to read, you're at the end!
  DB<3> seek $fh, 0, 0                                                
+                                                                     
+           
  DB<4> if ( not eof $fh ) { print "Read on, McDuff!\n" }             
+                                                                     
+           
Read on, McDuff!
  DB<5> @lines = <$fh>                                                
+                                                                     
+           
  DB<6> x @lines
  DB<7> chomp @lines                                                  
+                                                                     
+               
0  'First Line'
1  'Second Line'
2  'Last Line'
[download]

UpdateSidhekin is right in saying that +>> is clearer to read, however seek can be just as confusing if youve never dealt with it before.

'+<' is a better option

+< is another option, to be sure, but better? +>> states your intentions to read and append. +< leaves it open whether or not you intend to overwrite any of the original contents.

It would save you a seek, sure, but at a cost of clarity. TIMTOWTDI, indeed, but I think Flubb had the right idea.

print "Just another Perl ${\(trickster and hacker)},"
The Sidhekin proves Sidhe did it!

open (DAT, "+<$file") or die "$!";
[download]