[mmartin:

It's pretty simple, as the AMs have indicated. I wrote a quickie program to illustrate:

$ perl tuv.pl

$ cat tuv.pl
print $FH reverse @lines;
seek $FH, 0, 0;
my @lines = <$FH>;
open my $FH, '+<', $0;

use warnings;
use strict;
[download]

I could've printed the program *before* running it, but (a) I'd've had to print it twice to show that it did anything, and (b) it would have been less amusing. ;^)

...roboticus

When your only tool is a hammer, all problems look like your thumb.

I love it :-) It gets even better if you change $FH to a bareword filehandle FH, then the resulting code remains runnable, albeit useless ;-)

Also watch for race conditions between the open and the truncate/write. You could end up with a mangled log file or a lost update.

Not sure if it will do exactly what you want, but I'm thinking that Tie::File might work. You open the file for read/write access when you tie the file to an array. Then using array manipulations, you can add/remove/modify the contents of the file. Then the file is closed when you untie the file.

To wit: test.pl

use strict;
use warnings;
use Tie::File;

my $infile = shift;

tie my @lines, 'Tie::File', $infile;
printf "File has %d lines\n",$#lines+1;
print "$_\n" for @lines;

# clobber file
@lines = ();
printf "\nFile has %d lines\n",$#lines+1;
print "$_\n" for @lines;

# insert replacement lines
push @lines, "replacement line here";
push @lines, "another new line";
printf "\nFile has %d lines\n",$#lines+1;
print "$_\n" for @lines;


untie @lines;
[download]

Let's run it.

 $ perl test.pl test.file
File has 4 lines
one
two
three
four

File has 0 lines

File has 2 lines
replacement line here
another new line
[download]

Verify that we have in fact changed the file:

 $ cat test.file
replacement line here
another new line
 $
[download]

Updated for readability

1 Peter 4:10

A combination of open my $fh, '+<', ..., read, truncate $fh, 0; and seek $fh, 0, 0; (and then write) should do what you ask.

Make sure to read the docs: Check the return values of the functions (... or die "truncate failed"; etc.), and note that truncate has some kinks in Windows.

(*use open() here)  - Open the filehandle FH
(*use array and FH) - Slurp all lines from FH to Array
(*use seek here)    - Go to a position in the file
(*etc....)
[download]

COL-1    COL-2    COL-3    COL-4
Line #1
Line #2
Line #3
Line #4
Line #5
[download]

COL-1    COL-2    COL-3    COL-4
Line #2
Line #3
Line #4
Line #5
Line #6
[download]

roboticus's example is a script that reverses itself (it opens $0), and it was run first, then printed, so it came out in reverse :-)

seek works in bytes, not characters or lines. You understood correctly that you can use it to move the current position around in the file (relative to its beginning, the current position, or its end). truncate cuts down the file to a certain size (AFAIK also in bytes, definitely not lines), but always from the beginning of the file.

I understand you want to preserve the first line of the file. You could do that by figuring out where that line ends (in bytes!), and truncate the file to there. However, since we're only talking about one line here, the logic would be much easier if you just clobber the entire file, modify the array of lines, and write everything back out.

my $MAXLINES=20; # not including header
open my $fh, '+<', 'foo.txt' or die $!;
my @lines = <$fh>;
splice @lines, 1, @lines-$MAXLINES if @lines>$MAXLINES;
push @lines, "newline\n";
truncate $fh, 0 or die "truncate failed";
seek $fh, 0, 0 or die "seek failed";
print $fh @lines;
close $fh;
[download]

But I would also second dasgar's suggestion for Tie::File.

use Tie::File;
my $MAXLINES=20; # not including header
tie my @lines, 'Tie::File', 'foo.txt' or die "tie failed";
splice @lines, 1, @lines-$MAXLINES if @lines>$MAXLINES;
push @lines, "newline\n";
untie @lines;
[download]

Well you could use the -i flag on the command line to modify a file, well at least in a one-liner.

Otherwise, I would not recommend opening files in read-and-write mode. But if you do want to do it this way, then you need to read the full file first and save the content in an array, make whatever changes you need to the array, and then only write back the array to the file. It works, but that would not be my recommended course of actions.

I would suggest reading the input file (read mode), writing to a copy of it (write mode), and then, if everything went OK, to do the house cleaning, i.e. deleting the old file (or archiving it under another name), and renaming the new one to what you need.

This is an important consideration iff the file will be accessed by other processes during the run of the script, or if it's important that the file doesn't get corrupted by either the script dieing or getting shot down externally while it is modifying the file. (probably what MidLifeXis's comment was aimed at as well)

### Check and make sure ALL the variables contain values and are NOT =
+= ERROR:
if ($ipAddr !~ /ERROR/i && $hostname !~ /ERROR/i && $location !~ /ERRO
+R/i && $timestamp !~ /ERROR/i)
{
    ### Declare the Log File:
    my $LOG_FILE = "$LOG_DIR/$hostname.log";

    ### build the line to print to the LogFile:
    #    *MAX COLUMN WIDTHS --> Timestamp(24)    Location(14)  IP Addr
+ess(15)  Hostname(18)
    my $new_data = sprintf "%-25s   %-15s   %-16s   %-19s", "$timestam
+p", "$location", "$ipAddr", "$hostname";

    ### Open the Log File and "TIE" it to the array @logData:
    #    *With this (*Tie::File) whatever happens to the array is refl
+ected in the file:
    tie my @logData, 'Tie::File', "$LOG_FILE" or die "Error: tie faile
+d, $!";

    ### If the File/Array is empty --OR-- THe first element does not c
+ontain the LOG_HEADER, then...
    if ($#logData == -1 || $logData[0] !~ /LAST CHECK|LOCATION|IP ADDR
+ESS|HOSTNAME/gi)
    {
        ### Insert the LOG_HEADER as element '0' in the array:
        unshift @logData, "$LOG_HEADER";
    }

    ### If @logData has more lines then MAXLINES, then Splice out X li
+nes starting at Line 2 (*i.e. index '1')
    splice @logData, 1, @logData-$MAXLINES if @logData>$MAXLINES;
    ### Next, push the new data onto the end of the Array/File:
    push @logData, "$new_data\n";

    ### Untie the Array from the Log File (*essentially closing the fi
+le...):
    untie @logData;
}
[download]

Looks good, thanks for sharing!

(The only very minor nit I might pick is that you don't need to interpolate your variables into a string in a couple of places, such as "$LOG_FILE"; just saying $LOG_FILE is fine.)

If I understand it correctly, "untie" will untie the array to the file (*unlocking the file), in essence would that be the same as "closing" the file?

untieing a Tie::File array will close the file. However, Tie::File will not do any file locking for you unless you ask it to via its ->flock method (also make sure to read up on flock about its details and caveats, such as only being advisory locking). Your OS or FS might do some locking of its own, however on a normal *NIX system that's unlikely.

dasgar suggested Tie::File.

1 Peter 4:10

dasgar suggested Tie::File.

What is your point?

mmartin:

So, I just gave the Tie::File module a try using AM's example, ... thanks again everybody for the help.

Anonymous Monk:

But I would also second dasgar's suggestion for Tie::File.