Read and write a text file - perl

Question

How to read and write a text file and put it in the same file? I tried but I got empty files.
My code is :
#!/opt/lampp/bin/perl
print "Content-Type : text/html\n\n";
$ref = '/opt/lampp/htdocs/perl/Filehandling/data_1.txt';
open(REF, "+<", $ref) or die "Uable to open the file $ref: $!";
while (<REF>) {
if($_=~ m/Others/gi) {
$_ =~ s/Others/Other/gi;
print "$_\n";
}
}
$ref = '/opt/lampp/htdocs/perl/Filehandling/data_1.txt';
open(REF, "+>", $ref) or die "Uable to open the file $ref: $!";
print REF "$_\n";
close REF;
close REF;

Answer 1

perl -pi -e 's/Others/Other/gi' /opt/lampp/htdocs/perl/Filehandling/data_1.txt
The -i option edits a file in-place, i.e. overwrites the file with the new contents.
The s/// operator doesn't substitute anything if there is no match, so you don't have to check with m// if you have a match before attempting a substitution.
The flow control in your script is flawed; you open for reading, then print to standard output (not back to the file), then open for writing, but don't write anything useful (or, well, only the last line you read in the input loop).
What's with the Content-Type: header, do you want to run this as a CGI script? That sounds like a security problem.
Do you only want to print if there is a substitution? If so, try this:
perl -ni -e 's/Others/Other/ig and print' /opt/lampp/htdocs/perl/Filehandling/data_1.txt
Notice the change from -p which adds a read-and-print loop around your script, to -n which only reads, but doesn't print your file.

Answer 2

It seems that all you want is to s/Others/Other/gi in your data_1.txt.
You can make it a lot of easier with one line: perl -pi.bak -e's/Others/Other/gi' data_1.txt.
If you still want to read and write into the same file you can check the IO::InSitu module at CPAN.

Answer 3

Fᴍᴛᴇʏᴇᴡᴛᴋ: Learning How to Learn How to Update a Text File in Place
If only you were to Ｒᴇᴄᴏɴɴᴏɪᴛʀᴇ Ｔʜᴇ Ｆᴀʙᴜʟᴏᴜs perlfaq5 Ｍᴀɴᴘᴀɢᴇ — which is available on every Perl installation worldwide including your own — you would easily learn the answer to your question under that Ｆᴏʀᴍɪᴅᴀʙʟʏ Ａᴘᴏᴛʜᴇᴏsɪᴢᴇᴅ Ｑᴜᴀɴᴅᴀʀʏ entitled “How do I change, delete, or insert a line in a file, or append to the beginning of a file?”.
Somehow that key first step to problem solving failed to execute.
Learning how to efficiently search the standard Perl documentation set is one of the three keys steps in becoming a proficient Perl programmer. (For the record, the other two are to have a rolodex full of working examples and to have a particular itch you need scratched which you can use Perl to scratch it with.)
If you for whatever reason you either cannot or will not search the standard documentation, and so find yourself coming online begging help in doing something that was long ago answered in that documentation set, you will never be self‐enabling. You may also be perceived as something as a pest.
The Recipe Rolodex 📖
Looking beyond the standard documentation included with every Perl installation whose contents you should have searched before coming here, we find that O’Reilly’s Perl Cookbook chapter 7 on “File Access” and chapter 8 on “File Contents” contain several recipes particularly relevant to your current question, especially but not only those marked in bold below. The Perl Cookbook is a compendium of example code meant as the paired companion volume to Programming Perl. Arguably, the Cookbook is even more useful for the beginning Perl programmer than the Camel itself.
However, you can’t grep dead trees. So I will show you what you should look for, and how to grep it no matter whether you happen to possess the ungreppable dead‐tree version of that particular primer or not.
NB: While I sure that the publisher would be delighted if you were to purchase this essential Perl tome, whether as a dead tree or electronically, I recognize that this is not possible for everyone, so I below will show you how to access the relevant portions completely free of charge. In fact, I include them for your convenience.
First, the table of contents for chapter 7 of the Perl Cookbook:
Recipe 7.0: Introduction to File Access
Recipe 7.1: Opening a File
Recipe 7.2: Opening Files with Unusual Filenames
Recipe 7.3: Expanding Tildes in Filenames
Recipe 7.4: Making Perl Report Filenames in Error Messages
Recipe 7.5: Storing Filehandles into Variables
Recipe 7.6: Writing a Subroutine That Takes Filehandles as Built-ins Do
Recipe 7.7: Caching Open Output Filehandles
Recipe 7.8: Printing to Many Filehandles Simultaneously
Recipe 7.9: Opening and Closing File Descriptors by Number
Recipe 7.10: Copying Filehandles
Recipe 7.11: Creating Temporary Files
Recipe 7.12: Storing a File Inside Your Program Text
Recipe 7.13: Storing Multiple Files in the DATA Area
Recipe 7.14: Writing a Unix-Style Filter Program
☞ Recipe 7.15: Modifying a File in Place with Temporary File
☞ Recipe 7.16: Modifying a File in Place with -i Switch
☞ Recipe 7.17: Modifying a File in Place Without a Temporary File
Recipe 7.18: Locking a File
Recipe 7.19: Flushing Output
Recipe 7.20: Doing Non‐Blocking I/O
Recipe 7.21: Determining the Number of Unread Bytes
Recipe 7.22: Reading from Many Filehandles Without Blocking
Recipe 7.23: Reading an Entire Line Without Blocking
Recipe 7.24: Program: netlock
Recipe 7.25: Program: lockarea
And here is Chapter 8’s ᴛᴏᴄ:
☞ Recipe 8.0: Introduction to File Contents
Recipe 8.1: Reading Lines with Continuation Characters
Recipe 8.2: Counting Lines (or Paragraphs or Records) in a File
Recipe 8.3: Processing Every Word in a File
☞ Recipe 8.4: Reading a File Backwards by Line or Paragraph
Recipe 8.5: Trailing a Growing File
Recipe 8.6: Picking a Random Line from a File
Recipe 8.7: Randomizing All Lines
☞ Recipe 8.8: Reading a Particular Line in a File
Recipe 8.9: Processing Variable‐Length Text Fields
☞ Recipe 8.10: Removing the Last Line of a File
Recipe 8.11: Processing Binary Files
Recipe 8.12: Using Random‐Access I/O
☞ Recipe 8.13: Updating a Random‐Access File
Recipe 8.14: Reading a String from a Binary File
Recipe 8.15: Reading Fixed‐Length Records
Recipe 8.16: Reading Configuration Files
Recipe 8.17: Testing a File for Trustworthiness
Recipe 8.18: Treating a File as an Array
Recipe 8.19: Setting the Default I/O Layers
Recipe 8.20: Reading or Writing Unicode from a Filehandle
Recipe 8.21: Converting Microsoft®‐Proprietary Text Files into Standard Unicode
Recipe 8.22: Comparing the Contents of Two Files
Recipe 8.23: Pretending a String Is a File
Recipe 8.24: Program: tailwtmp
Recipe 8.25: Program: tctee
Recipe 8.26: Program: laston
Recipe 8.27: Program: Flat file indexes
Muddled Mental Models 😞
Chapter 8’s section 8.0 “Introduction to File Contents” is especially poignant, so much so that its copyrighted text I here reproduce by kind permission of its author:
Treating files as unstructured streams necessarily governs what you can do with them. You can read and write sequential, fixed‐size blocks of data at any location in the file, increasing its size if you write past the current end. Perl uses an I/O library that emulates C’s stdio(3) to implement reading and writing of variable‐length records like lines, paragraphs, and words.
What can’t you do to an unstructured file? Because you can’t insert or delete bytes anywhere but at end of file, you can't change easily the length of, insert, or delete records. An exception is the last record, which you can delete by truncating the file to the end of the previous record. For other modifications, you need to use a temporary file or work with a copy of the file in memory. If you need to do this a lot, a database system may be a better solution than a raw file. Standard with Perl as of v5.8 is the Tie::File module, which offers an array interface to files of records.
The last reference may be the most useful, because it offers a model of a text file that may better accord with the non‐programmer’s notion of what a text file is. To the operating system, a file is merely an ordered set of bytes, and the only operations that you can use on a file are read, write, seek, and truncate. There is on insert, there is no go‐to‐line‐number‐N, and there certainly is no search and replace. The operating system model is more that of a paper tape reader than it is a deck of cards. You can no more insert new data in the middle of a file than you can wedge a new sector between existing ones on a hard disk. They don’t call it a hard disk for nothing, you know.
The problem is that the non‐programmer has no experience with the operating system’s model of a fixed file filled with bytes. Her only model for a text file is one whose operations match that of the text editor she is used to, one which in these post–pre‐Internet [sic] days of computing often more resembles a child’s video game than it does a serious tool for getting real work done.
Whether you have a video‐game version or a power‐tool version, all text editors are almost always line based, and allow one to move lines around, search by line, change lines including their lengths, insert into the middle of a file or delete from the middle shortening everything up. Even her notion of a character is very different from the operating system, since a user‐visible grapheme can easily comprise multiple programmer-visible code points, and each of these code points can easily comprise multiple operating‐system–visible code units.
This non‐programmer model does not work with real operating system files. The Tie::File module provides an abstraction layer that can help present a higher level and perhaps more non‐programmer–friendly model of a text file.
ᴘʟᴇᴀᴄ: The Programming Language Examples Alike Cookbook
Have you ever wanted a Rosetta Stone for programming languages? If so, then today is your lucky day. 😹
Although the published Perl Cookbook’s complete code is readly available for free and easy download, you might also find interesting the ᴘʟᴇᴀᴄ project, the multilingual Programming Language Examples Alike Cookbook. It includes not just the full Perl Cookbook code, but also translations in varying states of completeness into other popular programming languages like Ruby and Python, old languages like Rexx and TCL, nascent languages like Go and Groovy, and exotic languages like Haskell and OCaml (no relation to 🐪 :).
I quote below from the ᴘʟᴇᴀᴄ project’s source for the three relevant recipes from the Perl Cookbook.
Recipe 7.15: Modifying a File in Place with a Temporary File
# ^^PLEAC^^_7.8
#-----------------------------
open(OLD, "< $old") or die "can't open $old: $!";
open(NEW, "> $new") or die "can't open $new: $!";
while (<OLD>) {
# change $_, then...
print NEW $_ or die "can't write $new: $!";
}
close(OLD) or die "can't close $old: $!";
close(NEW) or die "can't close $new: $!";
rename($old, "$old.orig") or die "can't rename $old to $old.orig: $!";
rename($new, $old) or die "can't rename $new to $old: $!";
#-----------------------------
while (<OLD>) {
if ($. == 20) {
print NEW "Extra line 1\n";
print NEW "Extra line 2\n";
}
print NEW $_;
}
#-----------------------------
while (<OLD>) {
next if 20 .. 30;
print NEW $_;
}
#-----------------------------
Recipe 7.16: Modifying a File in Place with the -i Switch
# ^^PLEAC^^_7.9
#-----------------------------
#% perl -i.orig -p -e 'FILTER COMMAND' file1 file2 file3 ...
#-----------------------------
#!/usr/bin/perl -i.orig -p
# filter commands go here
#-----------------------------
#% perl -pi.orig -e 's/DATE/localtime/e'
#-----------------------------
while (<>) {
if ($ARGV ne $oldargv) { # are we at the next file?
rename($ARGV, $ARGV . '.orig');
open(ARGVOUT, ">$ARGV"); # plus error check
select(ARGVOUT);
$oldargv = $ARGV;
}
s/DATE/localtime/e;
}
continue{
print;
}
select (STDOUT); # restore default output
#-----------------------------
#Dear Sir/Madam/Ravenous Beast,
# As of DATE, our records show your account
#is overdue. Please settle by the end of the month.
#Yours in cheerful usury,
# --A. Moneylender
#-----------------------------
#Dear Sir/Madam/Ravenous Beast,
# As of Sat Apr 25 12:28:33 1998, our records show your account
#is overdue. Please settle by the end of the month.
#Yours in cheerful usury,
# --A. Moneylender
#-----------------------------
#% perl -i.old -pe 's{\bhisvar\b}{hervar}g' *.[Cchy]
#-----------------------------
# set up to iterate over the *.c files in the current directory,
# editing in place and saving the old file with a .orig extension
local $^I = '.orig'; # emulate -i.orig
local #ARGV = glob("*.c"); # initialize list of files
while (<>) {
if ($. == 1) {
print "This line should appear at the top of each file\n";
}
s/\b(p)earl\b/${1}erl/ig; # Correct typos, preserving case
print;
} continue {close ARGV if eof}
#-----------------------------
Recipe 7.17: Modifying a File in Place Without a Temporary File
# ^^PLEAC^^_7.10
#-----------------------------
open(FH, "+< FILE") or die "Opening: $!";
#ARRAY = <FH>;
# change ARRAY here
seek(FH,0,0) or die "Seeking: $!";
print FH #ARRAY or die "Printing: $!";
truncate(FH,tell(FH)) or die "Truncating: $!";
close(FH) or die "Closing: $!";
#-----------------------------
open(F, "+< $infile") or die "can't read $infile: $!";
$out = '';
while (<F>) {
s/DATE/localtime/eg;
$out .= $_;
}
seek(F, 0, 0) or die "can't seek to start of $infile: $!";
print F $out or die "can't print to $infile: $!";
truncate(F, tell(F)) or die "can't truncate $infile: $!";
close(F) or die "can't close $infile: $!";
#----------------------------
Conclusion
There. If that doesn’t point the way to answering your question, I don’t know what will. But I bet it did. Congrats! 👏