But in order for that to work as expected, you'll have to be careful to make sure that the replacement data you put in contains exactly the same number of bytes as the original data you are replacing in the file.

For example, suppose you have a string like "foobar", starting at byte offset 20 in the file. If you seek to that offset and write "goober" (same number of bytes), that will "replace" the foobar string just fine. But if you seek to byte offset 20 and write something shorter, the last byte(s) of "foobar" will still be in file unchanged, and if you write something longer, whatever follows "foobar" will be overwritten as well.

If your plan involves cases where the file should end up with a different byte count when you're done, you won't be able to do the editing "in place". You can try looking at Tie::File, although I'm not sure it does what you want in particular.

If you want better help, try showing us a small amount of real data, together with some code that you've tried, and tell us what kind of result you really want, given that your code isn't producing that result.

Consider:

use strict;
use warnings;

my $testFile = 'delme.txt';

unlink $testFile;
open my $ioFile, '>', $testFile or die "Failed to open $testFile for u
+pdate: $!\n";

print $ioFile "This is some output text\n";

my $seekBackPoint = tell $ioFile;

print $ioFile "This line will get overwritten (at least partially)\n";
seek $ioFile, $seekBackPoint, 0;
print $ioFile "Overwrite part of a line.\n";

close $ioFile;

open my $iFile, '<', $testFile or die "Failed to open $testFile for re
+ading: $!\n";
print <$iFile>;
close $iFile;
[download]

Prints:

This is some output text
Overwrite part of a line.
ten (at least partially)
[download]

Note: use lexical file handles and the three parameter version of open.

I'm not sure from your description, but you may be looking for seek.

open INFILE ...
open OUTFILE ...
while(<INFILE>){
print OUTFILE ...
}
close INFILE
close OUTFILE
rename OUTFILE, INFILE
[download]

Thanks Monk. But why it was desinged like this ? why we could not able to write to files while it was opened. if we are able to append , then we should able to write to a file right ? is there any dependency for this operation ? or do we have to unlink the handle while wrting to a file . i could not found much info from net regarding this ! . could you please help me to know this .

Think of the file data on the disk as a sequential stream of bits (this is an approximation- but a good thought model here). Or perhaps a sequence of numbers: 123789, if we want the sequence 1234789, that means that the data 789 has to move down to make room! We have to carve a "hole" for the new "4" data and that is a complex thing to do. If say, the new "4" data is exactly the same size as the "7" data, and I mean *EXACTLY*, we could use seek() to move to that position and wind up with 123489 (replace 7 data with 4).

Think of cassette tapes, if you record 3 songs and you want to add a new song at the beginning of the tape, you have to record the new song and then all of the next 3 songs over again. The disk works like that.

Far and away your best bet if these files aren't huge, is to open the file for read, slurp it into a memory array, do what want to that data, open a new file for write, write the data, close the file and then delete the old file and rename the new file to the old file's name.

Tie::File would do some grunt work for you, but this is what it essentially does and its not portable to Windows if that matters to you.

To be frank, you are in way over your head if you intend to write something that can insert things into an existing file by yourself. That is definitely not beginner stuff!

If the idea of reading the file into memory, working on it and writing it back out doesn't work, then this is time for using a Perl DB module or Tie::File.

Anyway it works this way because the hardware works that way.

Maybe I'm reading too much into your example text, but this kind of query("Hello, how are you?") / response("Fine. How about you?") system is better implemented with pipes or sockets