#!/usr/bin/perl 
use strict;
use warnings;  


my $infile = '/home/yanni/scripts/testfiles/list_names';
my $outfile = "$infile.tmp";

open (my $in,  '<', $infile ) || die "Can't open $infile $!\n";
open (my $out, '>', $outfile) || die "Can't open $outfile $!\n";

while (<$in>)
{   
    print $out $_;
    if ($.== 3) {print $out "Simon\n";} 
}

close ($in);
close ($out);
rename ($outfile, $infile) || die "Unable to rename: $!";
[download]

Where to start. First, what you are trying to do is invalid. Unless you have fixed length records, it is not possible to insert a record into the middle of a text file. That is the case regardless of the language.

You are right that it's not language dependent. It's file system dependent. Most Unix and Windows filesystems where files are just streams of bytes - and there it's not possible to insert records without copying sections of the file. But there are filesystems where files are lists of records - files look a bit like row-based database tables. IIRC, VMS has the ability to use such filesystems.

But the above is just some pedantery, chances the OP is using such a file system are tiny.

Thank you very much cdarke for explaining my mistakes.

Your script works perfectly.

You start the thread by saying:

I've been reading a not very useful book for a few weeks now.

and it strikes me that the number of problems in the OP script might be an indicator of just how "not very useful" that book really is. Have you checked out the Reviews section here at the Monastery? Is your book already reviewed there? (If not, perhaps you could take your revenge on the "not very useful" author by contributing a review of the book.)

Oh, and maybe you can find a better book... (maybe our Book Reviews nook will help you find one). Personally, my own favorite reading has always been the documentation that comes with perl -- starting perhaps with perl.

Well, the first question is "How would you do this in any arbitrary computer language?" The second is "How do you expect to insert a record into a file without writing into it?"

There are numerous ways of doing this in Perl: localize $/, and slurp the file in as one chunk, and read the file into an array, and read the file a line at a time, and either write the modified file as a temp file and use rename to overwrite the old file or use the -i option to edit it in place. You could also use Tie::File, although that seems to some of the aesthetics of using a sledgehammer to kill a gnat.

Here's an in-place edit example:

my $file = "mydata.txt";

# read data from file
open my $fh, '+<', $file or die "can't open file $file : $!\n";
my @data = <$fh>;
chomp @data;

# modify data (add item)
@data = sort (@data, 'Simon');

# rewind back to beginning
seek($fh, 0, 0);
for my $d (@data) {
  # write data back to file (skips blank lines)
  print $fh "$d\n" if $d;
}
# if new file is shorter than original, throw away extra
truncate($fh, tell($fh));

close $fh;
[download]

Note that opening the file as '+<' means 'update mode'. The basic idea is read the file, modify the contents, then rewind back to the beginning with seek, write the new data back to the file - overwriting the original contents. If the new file is larger, you could stop here, but if it's shorter, you'll need to throw away the "extra" using truncate (so it's best to always use it, just in case). You might want to apply file locking here, depending on the application. For example, if you were using this in a webapp to add new users to an email list, you could potentially have multiple processes trying to update the file at the same time. Just add a flock($fh,2) after the open statement.

Also note that this assumes that the file is not so big that it can't be read into memory all at once.

You might also want to read up on perl's -i command line switch (in place edit). It actually copies the input to a temp file, reads from the temp file, and writes to the original file name - so the end results is that the output overwrites the original input.

That seems like a contortion to avoid opening an input filehandle and a separate output filehandle.

use strict;
use warnings;

my $filename = "inputfile.txt";
my $outputfile = $filename . "out";
my( $infh, $outfh );

open(  $infh, '<', $filename   ) or die $!;
open( $outfh, '>', $outputfile ) or die $!;

while( my $line = <$infh> ) {
    if( $line =~ /\bWilliam\b/i ) {
        print $outfh "Nick\n";
    }
    print $line;
}

close $infh  or die $!;
close $outfh or die $!;

rename $outputfile, $filename or die $!;
[download]

This is pretty close to what the -i commandline switch does for Perl one liners, with the exception of the "-i.bak" behavior, which could easily be implemented here too.

This whole thing could be written as a one liner, by the way:

perl -pi.bak -e "/\bWilliam\b/i && print qq/Nick\n/;" filename.txt

Obviously I forgot the names you're searching on, but the principle works.




Dave

There are some advantages to working in-place over creating a temporary file:

• File permission and ownership is maintained.
• Using a temporary file requires more permissions.
• Using a temporary file may complicate the locking system required.
• Working in-place can be faster in some situations.

This is pretty close to what the -i commandline switch does for Perl one liners

-i is closer to

open(my $fh_in,  '<', $qfn);
unlink($qfn);
open(my $fh_out, '>', $qfn);
...
[download]

for now.