Globally replace text in several files
You are encouraged to solve this task according to the task description, using any language you may know.
The task is to replace every occuring instance of a piece of text in a group of text files with another one. For this task we want to replace the text "Goodbye London!" with "Hello New York!" for a list of files.
Ada
<lang Ada>with Ada.Strings.Unbounded, Ada.Text_IO, Ada.Command_Line, Ada.Directories;
procedure Global_Replace is
subtype U_String is Ada.Strings.Unbounded.Unbounded_String;
function "+"(S: String) return U_String renames
Ada.Strings.Unbounded.To_Unbounded_String;
function "-"(U: U_String) return String renames
Ada.Strings.Unbounded.To_String;
procedure String_Replace(S: in out U_String; Pattern, Replacement: String) is
-- example: if S is "Mary had a XX lamb", then String_Replace(S, "X", "little");
-- will turn S into "Mary had a littlelittle lamb"
-- and String_Replace(S, "Y", "small"); will not change S
Index : Natural;
begin
loop
Index := Ada.Strings.Unbounded.Index(Source => S, Pattern => Pattern);
exit when Index = 0;
Ada.Strings.Unbounded.Replace_Slice
(Source => S, Low => Index, High => Index+Pattern'Length-1,
By => Replacement);
end loop;
end String_Replace;
procedure File_Replace(Filename: String; Pattern, Replacement: String) is
-- applies String_Rplace to each line in the file with the given Filename
-- propagates any exceptions, when, e.g., the file does not exist
I_File, O_File: Ada.Text_IO.File_Type;
Line: U_String;
Tmp_Name: String := Filename & ".tmp";
-- name of temporary file; if that file already exists, it will be overwritten
begin
Ada.Text_IO.Open(I_File, Ada.Text_IO.In_File, Filename);
Ada.Text_IO.Create(O_File, Ada.Text_IO.Out_File, Tmp_Name);
while not Ada.Text_IO.End_Of_File(I_File) loop
Line := +Ada.Text_IO.Get_Line(I_File);
String_Replace(Line, Pattern, Replacement);
Ada.Text_IO.Put_Line(O_File, -Line);
end loop;
Ada.Text_IO.Close(I_File);
Ada.Text_IO.Close(O_File);
Ada.Directories.Delete_File(Filename);
Ada.Directories.Rename(Old_Name => Tmp_Name, New_Name => Filename);
end File_Replace;
Pattern: String := Ada.Command_Line.Argument(1); Replacement: String := Ada.Command_Line.Argument(2);
begin
Ada.Text_IO.Put_Line("Replacing """ & Pattern
& """ by """ & Replacement & """ in"
& Integer'Image(Ada.Command_Line.Argument_Count - 2)
& " files.");
for I in 3 .. Ada.Command_Line.Argument_Count loop
File_Replace(Ada.Command_Line.Argument(I), Pattern, Replacement);
end loop;
end Global_Replace;</lang>
Ouput:
> ls ?.txt 1.txt 2.txt x.txt y.txt > more 2.txt This is a text. "Goodbye London!" "Goodbye London!" "Byebye London!" "Byebye London!" "Byebye London!" > ./global_replace "Goodbye London" "Hello New York" ?.txt Replacing "Goodbye London" by "Hello New York" in 4 files. > more 2.txt This is a text. "Hello New York!" "Hello New York!" "Byebye London!" "Byebye London!" "Byebye London!"
AutoHotkey
<lang AutoHotkey>SetWorkingDir %A_ScriptDir% ; Change the working directory to the script's location listFiles := "a.txt|b.txt|c.txt" ; Define a list of files in the current working directory loop, Parse, listFiles, | { ; The above parses the list based on the | character fileread, contents, %A_LoopField% ; Read the file fileDelete, %A_LoopField% ; Delete the file stringReplace, contents, contents, Goodbye London!, Hello New York!, All ; replace all occurrences fileAppend, %contents%, %A_LoopField% ; Re-create the file with new contents } </lang>
BASIC
Pass the files on the command line (i.e. global-replace *.txt).
<lang qbasic>CONST matchtext = "Goodbye London!" CONST repltext = "Hello New York!" CONST matchlen = LEN(matchtext)
DIM L0 AS INTEGER, x AS INTEGER, filespec AS STRING, linein AS STRING
L0 = 1 WHILE LEN(COMMAND$(L0))
filespec = DIR$(COMMAND$(L0))
WHILE LEN(filespec)
OPEN filespec FOR BINARY AS 1
linein = SPACE$(LOF(1))
GET #1, 1, linein
DO
x = INSTR(linein, matchtext)
IF x THEN
linein = LEFT$(linein, x - 1) & repltext & MID$(linein, x + matchlen)
' If matchtext and repltext are of equal length (as in this example)
' then you can replace the above line with this:
' MID$(linein, x) = repltext
' This is somewhat more efficient than having to rebuild the string.
ELSE
EXIT DO
END IF
LOOP
' If matchtext and repltext are of equal length (as in this example), or repltext
' is longer than matchtext, you could just write back to the file while it's open
' in BINARY mode, like so:
' PUT #1, 1, linein
' But since there's no way to reduce the file size via BINARY and PUT, we do this:
CLOSE
OPEN filespec FOR OUTPUT AS 1
PRINT #1, linein;
CLOSE
filespec = DIR$
WEND
L0 += 1
WEND</lang>
C
<lang C>#include <stdio.h>
- include <stdlib.h>
- include <stddef.h>
- include <string.h>
- include <sys/types.h>
- include <fcntl.h>
- include <sys/stat.h>
- include <unistd.h>
- include <err.h>
- include <string.h>
char * find_match(char *buf, char * buf_end, char *pat, size_t len) { ptrdiff_t i; char *start = buf; while (start + len < buf_end) { for (i = 0; i < len; i++) if (start[i] != pat[i]) break;
if (i == len) return start; start++; } return 0; }
int replace(char *from, char *to, char *fname) {
- define bail(msg) { warn(msg" '%s'", fname); goto done; }
struct stat st; int ret = 0; char *buf = 0, *start, *end; size_t len = strlen(from), nlen = strlen(to); int fd = open(fname, O_RDWR);
if (fd == -1) bail("Can't open"); if (fstat(fd, &st) == -1) bail("Can't stat"); if (!(buf = malloc(st.st_size))) bail("Can't alloc"); if (read(fd, buf, st.st_size) != st.st_size) bail("Bad read");
start = buf; end = find_match(start, buf + st.st_size, from, len); if (!end) goto done; /* no match found, don't change file */
ftruncate(fd, 0); lseek(fd, 0, 0); do { write(fd, start, end - start); /* write content before match */ write(fd, to, nlen); /* write replacement of match */ start = end + len; /* skip to end of match */ /* find match again */ end = find_match(start, buf + st.st_size, from, len); } while (end);
/* write leftover after last match */ if (start < buf + st.st_size) write(fd, start, buf + st.st_size - start);
done: if (fd != -1) close(fd); if (buf) free(buf); return ret; }
int main() { char *from = "Goodbye, London!"; char *to = "Hello, New York!"; char * files[] = { "test1.txt", "test2.txt", "test3.txt" }; int i;
for (i = 0; i < sizeof(files)/sizeof(char*); i++) replace(from, to, files[i]);
return 0; }</lang>
C++
<lang cpp>#include <fstream>
- include <iterator>
- include <boost/regex.hpp>
- include <string>
- include <iostream>
int main( int argc , char *argv[ ] ) {
boost::regex to_be_replaced( "Goodbye London\\s*!" ) ;
std::string replacement( "Hello New York!" ) ;
for ( int i = 1 ; i < argc ; i++ ) {
std::ifstream infile ( argv[ i ] ) ;
if ( infile ) {
std::string filetext( (std::istreambuf_iterator<char>( infile )) , std::istreambuf_iterator<char>( ) ) ; std::string changed ( boost::regex_replace( filetext , to_be_replaced , replacement )) ; infile.close( ) ; std::ofstream outfile( argv[ i ] , std::ios_base::out | std::ios_base::trunc ) ; if ( outfile.is_open( ) ) { outfile << changed ; outfile.close( ) ; }
}
else
std::cout << "Can't find file " << argv[ i ] << " !\n" ;
} return 0 ;
}</lang>
D
<lang d>import std.file, std.array;
void main() {
auto from = "Goodbye London!", to = "Hello, New York!";
foreach (fn; "a.txt b.txt c.txt".split()) {
write(fn, replace(cast(string)read(fn), from, to));
}
}</lang>
Go
<lang go>package main
import (
"bytes" "io/ioutil" "log" "os"
)
func main() {
gRepNFiles("Goodbye London!", "Hello New York!", []string{
"a.txt",
"b.txt",
"c.txt",
})
}
func gRepNFiles(olds, news string, files []string) {
oldb := []byte(olds)
newb := []byte(news)
for _, fn := range files {
if err := gRepFile(oldb, newb, fn); err != nil {
log.Println(err)
}
}
}
func gRepFile(oldb, newb []byte, fn string) (err error) {
var f *os.File
if f, err = os.OpenFile(fn, os.O_RDWR, 0); err != nil {
return
}
defer func() {
if cErr := f.Close(); err == nil {
err = cErr
}
}()
var b []byte
if b, err = ioutil.ReadAll(f); err != nil {
return
}
if bytes.Index(b, oldb) < 0 {
return
}
r := bytes.Replace(b, oldb, newb, -1)
if err = f.Truncate(0); err != nil {
return
}
_, err = f.WriteAt(r, 0)
return
}</lang>
Icon and Unicon
This example uses the Unicon stat function. It can be rewritten for Icon to aggregate the file in a reads loop. <lang Icon>procedure main() globalrepl("Goodbye London","Hello New York","a.txt","b.txt") # variable args for files end
procedure globalrepl(old,new,files[])
every fn := !files do
if s := reads(f := open(fn,"bu"),stat(f).size) then {
writes(seek(f,1),replace(s,old,new))
close(f)
}
else write(&errout,"Unable to open ",fn)
end
link strings # for replace</lang>
J
If files is a variable with the desired list of file names:
<lang j>require'strings' (1!:2~rplc&('Goodbye London!';'Hello New York!')@(1!:1))"0 files</lang>
Liberty BASIC
<lang lb> nomainwin
file$( 1) ="data1.txt" file$( 2) ="data2.txt" file$( 3) ="data3.txt"
for i =1 to 3
open file$( i) for input as #i
orig$ =input$( #i, lof( #i))
close #i
dummy$ =FindReplace$( orig$, "Goodbye London!", "Hello New York!", 1)
open "RC" +file$( i) for output as #o
#o dummy$;
close #o
next i
end
function FindReplace$( FindReplace$, find$, replace$, replaceAll) ' Target string, string to find, string to replace it with, flag 0/1 for 'replace all occurrences'.
if ( ( FindReplace$ <>"") and ( find$ <>"") ) then
fLen =len( find$)
rLen =len( replace$)
do
fPos =instr( FindReplace$, find$, fPos)
if not( fPos) then exit function
pre$ =left$( FindReplace$, fPos -1)
post$ =mid$( FindReplace$, fPos +fLen)
FindReplace$ =pre$ +replace$ +post$
fPos =fPos +( rLen -fLen) +1
loop while (replaceAll)
end if
end function </lang>
Lua
<lang lua>filenames = { "f1.txt", "f2.txt" }
for _, fn in pairs( filenames ) do
fp = io.open( fn, "r" ) str = fp:read( "*all" ) str = string.gsub( str, "Goodbye London!", "Hello New York!" ) fp:close()
fp = io.open( fn, "w+" ) fp:write( str ) fp:close()
end</lang>
OpenEdge/Progress
<lang progress>FUNCTION replaceText RETURNS LOGICAL (
i_cfile_list AS CHAR, i_cfrom AS CHAR, i_cto AS CHAR
):
DEF VAR ii AS INT. DEF VAR lcfile AS LONGCHAR.
DO ii = 1 TO NUM-ENTRIES( i_cfile_list ):
COPY-LOB FROM FILE ENTRY( ii, i_cfile_list ) TO lcfile.
lcfile = REPLACE( lcfile, i_cfrom, i_cto ).
COPY-LOB FROM lcfile TO FILE ENTRY( ii, i_cfile_list ).
END.
END FUNCTION. /* replaceText */
replaceText(
"a.txt,b.txt,c.txt", "Goodbye London!", "Hello New York!"
).</lang>
Pascal
<lang pascal>Program StringReplace;
uses
Classes, StrUtils;
const
fileName: array[1..3] of string = ('a.txt', 'b.txt', 'c.txt');
matchText = 'Goodbye London!';
replaceText = 'Hello New York!';
var
AllText: TStringlist; i, j: integer;
begin
for j := low(fileName) to high(fileName) do
begin
AllText := TStringlist.Create;
AllText.LoadFromFile(fileName[j]);
for i := 0 to AllText.Count-1 do
AllText.Strings[i] := AnsiReplaceStr(AllText.Strings[i], matchText, replaceText);
AllText.SaveToFile(fileName[j]);
AllText.Destroy;
end;
end.</lang>
Perl
<lang bash>perl -pi -e "s/Goodbye London\!/Hello New York\!/g;" a.txt b.txt c.txt</lang>
Perl 6
Current Perl 6 implementations do not yet support the -i flag for editing files in place, so we roll our own (rather unsafe) version:
<lang perl6>spurt $_, slurp($_).subst('Goodbye London!', 'Hello New York!', :g)
for <a.txt b.txt c.txt>;</lang>
PicoLisp
<lang PicoLisp>(for File '(a.txt b.txt c.txt)
(call 'mv File (tmp File))
(out File
(in (tmp File)
(while (echo "Goodbye London!")
(prin "Hello New York!") ) ) ) )</lang>
PowerBASIC
<lang powerbasic>$matchtext = "Goodbye London!" $repltext = "Hello New York!"
FUNCTION PBMAIN () AS LONG
DIM L0 AS INTEGER, filespec AS STRING, linein AS STRING
L0 = 1
WHILE LEN(COMMAND$(L0))
filespec = DIR$(COMMAND$(L0))
WHILE LEN(filespec)
OPEN filespec FOR BINARY AS 1
linein = SPACE$(LOF(1))
GET #1, 1, linein
' No need to jump through FB's hoops here...
REPLACE $matchtext WITH $repltext IN linein
PUT #1, 1, linein
SETEOF #1
CLOSE
filespec = DIR$
WEND
INCR L0
WEND
END FUNCTION</lang>
PureBasic
<lang PureBasic>Procedure GRTISF(List File$(), Find$, Replace$)
Protected Line$, Out$, OutFile$, i
ForEach File$()
fsize=FileSize(File$())
If fsize<=0: Continue: EndIf
If ReadFile(0, File$())
i=0
;
; generate a temporary file in a safe way
Repeat
file$=GetTemporaryDirectory()+base$+"_"+Str(i)+".tmp"
i+1
Until FileSize(file$)=-1
i=CreateFile(FileID, file$)
If i
; Copy the infile to the outfile while replacing any needed text
While Not Eof(0)
Line$=ReadString(0)
Out$=ReplaceString(Line$,Find$,Replace$)
WriteString(1,Out$)
Wend
CloseFile(1)
EndIf
CloseFile(0)
If i
; If we made a new file, copy it back.
CopyFile(file$, File$())
DeleteFile(file$)
EndIf
EndIf
Next
EndProcedure</lang> Implementation
NewList Xyz$() AddElement(Xyz$()): Xyz$()="C:\\a.txt" AddElement(Xyz$()): Xyz$()="C:\\b.txt" AddElement(Xyz$()): Xyz$()="D:\\c.txt" GRTISF(Xyz$(), "Goodbye London", "Hello New York")
Python
From Python docs. (Note: in-place editing does not work for MS-DOS 8+3 filesystems.).
<lang python>import fileinput
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end=)
</lang>
Ruby
Like Perl:
ruby -pi -e "gsub('Goodbye London!', 'Hello New York!')" a.txt b.txt c.txt
Run BASIC
<lang runbasic>file$(1) ="data1.txt" file$(2) ="data2.txt" file$(3) ="data3.txt"
for i = 1 to 3
open file$(i) for input as #in
fileBefore$ = input$( #in, lof( #in))
close #in
fileAfter$ = strRep$(fileBefore$, "Goodbye London!", "Hello New York!")
open "new_" + file$(i) for output as #out
print #out,fileAfter$;
close #out
next i end
' -------------------------------- ' string replace - rep str with ' -------------------------------- FUNCTION strRep$(str$,rep$,with$) ln = len(rep$) ln1 = ln - 1 i = 1 while i <= len(str$)
if mid$(str$,i,ln) = rep$ then
strRep$ = strRep$ + with$
i = i + ln1
else
strRep$ = strRep$ + mid$(str$,i,1)
end if
i = i + 1 WEND END FUNCTION</lang>
Seed7
<lang seed7>$ include "seed7_05.s7i";
include "getf.s7i";
const proc: main is func
local
var string: fileName is "";
var string: content is "";
begin
for fileName range [] ("a.txt", "b.txt", "c.txt") do
content := getf(fileName);
content := replace(content, "Goodbye London!", "Hello New York!");
putf(fileName, content);
end for;
end func;</lang>
Tcl
<lang tcl>package require Tcl 8.5 package require fileutil
- Parameters to the replacement
set from "Goodbye London!" set to "Hello New York!"
- Which files to replace
set fileList [list a.txt b.txt c.txt]
- Make a command fragment that performs the replacement on a supplied string
set replacementCmd [list string map [list $from $to]]
- Apply the replacement to the contents of each file
foreach filename $fileList {
fileutil::updateInPlace $filename $replacementCmd
}</lang>
TUSCRIPT
<lang tuscript> $$ MODE TUSCRIPT files="a.txt'b.txt'c.txt"
BUILD S_TABLE search = ":Goodbye London!:"
LOOP file=files
ERROR/STOP OPEN (file,WRITE,-std-)
ERROR/STOP CREATE ("scratch",FDF-o,-std-)
ACCESS q: READ/STREAM/RECORDS/UTF8 $file s,aken+text/search+eken
ACCESS s: WRITE/ERASE/STREAM/UTF8 "scratch" s,aken+text+eken
LOOP
READ/EXIT q
IF (text.ct.search) SET text="Hello New York!"
WRITE/ADJUST s
ENDLOOP
ENDACCESS/PRINT q
ENDACCESS/PRINT s
ERROR/STOP COPY ("scratch",file)
ERROR/STOP CLOSE (file)
ENDLOOP ERROR/STOP DELETE ("scratch") </lang>
TXR
Another use of a screwdriver as a hammer.
The dummy empty output at the end serves a dual purpose. Firstly, without argument clauses following it, the @(next `!mv ...`) will not actually happen (lazy evaluation!). Secondly, if a txr script performs no output on standard output, the default action of dumping variable bindings kicks in.
<lang txr>@(next :args) @(collect) @file @(next `@file`) @(freeform) @(coll :gap 0)@notmatch@{match /Goodbye, London!/}@(end)@*tail@/\n/ @(output `@file.tmp`) @(rep)@{notmatch}Hello, New York!@(end)@tail @(end) @(next `!mv @file.tmp @file`) @(output) @(end) @(end)</lang> Run:
$ cat foo.txt aaaGoodbye, London!aaa Goodbye, London! $ cat bar.txt aaaGoodbye, London!aaa Goodbye, London! $ txr replace-files.txr foo.txt bar.txt $ cat foo.txt aaaHello, New York!aaa Hello, New York! $ cat bar.txt aaaHello, New York!aaa Hello, New York!
Run, with no directory permissions:
$ chmod a-w . $ txr replace-files.txr foo.txt bar.txt txr: unhandled exception of type file_error: txr: could not open foo.txt.tmp (error 13/Permission denied) false