Globally replace text in several files: Difference between revisions

m
→‎{{header|Wren}}: Changed to Wren S/H
(→‎{{header|Ada}}: Added Ada version)
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(106 intermediate revisions by 55 users not shown)
Line 1:
{{task}}
{{task}}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.
 
;Task:
Replace every occurring 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.
<br><br>
 
=={{header|11l}}==
<syntaxhighlight lang="11l">L(fname) fs:list_dir(‘.’)
I fname.ends_with(‘.txt’)
V fcontents = File(fname).read()
File(fname, ‘w’).write(fcontents.replace(‘Goodbye London!’, ‘Hello, New York!’))
</syntaxhighlight>
 
=={{header|Ada}}==
 
<langsyntaxhighlight Adalang="ada">with Ada.Strings.Unbounded, Ada.Text_IO, Ada.Command_Line, Ada.Directories;
 
procedure Global_Replace is
Line 61 ⟶ 76:
File_Replace(Ada.Command_Line.Argument(I), Pattern, Replacement);
end loop;
end Global_Replace;</langsyntaxhighlight>
 
Ouput:
Line 81 ⟶ 96:
"Hello New York!"
"Byebye London!" "Byebye London!" "Byebye London!" </pre>
 
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">files: select list "." 'f -> suffix? ".txtfile"
 
loop files 'file ->
write file replace read file "Goodbye London!" "Hello New York!"</syntaxhighlight>
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="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, |
Line 93 ⟶ 114:
fileAppend, %contents%, %A_LoopField% ; Re-create the file with new contents
}
</syntaxhighlight>
</lang>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f GLOBALLY_REPLACE_TEXT_IN_SEVERAL_FILES.AWK filename(s)
BEGIN {
old_text = "Goodbye London!"
new_text = "Hello New York!"
}
BEGINFILE {
nfiles_in++
text_found = 0
delete arr
}
{ if (gsub(old_text,new_text,$0) > 0) {
text_found++
}
arr[FNR] = $0
}
ENDFILE {
if (text_found > 0) {
nfiles_out++
close(FILENAME)
for (i=1; i<=FNR; i++) {
printf("%s\n",arr[i]) >FILENAME
}
}
}
END {
printf("files: %d read, %d updated\n",nfiles_in,nfiles_out)
exit(0)
}
</syntaxhighlight>
 
{{works with|gawk}}
<syntaxhighlight lang="awk">@include "readfile"
BEGIN {
while(++i < ARGC)
print gensub("Goodbye London!","Hello New York!","g", readfile(ARGV[i])) > ARGV[i]
}</syntaxhighlight>
 
=={{header|BASIC}}==
Line 100 ⟶ 160:
Pass the files on the command line (i.e. <code>global-replace *.txt</code>).
 
<langsyntaxhighlight lang="qbasic">CONST matchtext = "Goodbye London!"
CONST repltext = "Hello New York!"
CONST matchlen = LEN(matchtext)
Line 137 ⟶ 197:
WEND
L0 += 1
WEND</langsyntaxhighlight>
 
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> FindThis$ = "Goodbye London!"
ReplaceWith$ = "Hello New York!"
DIM Files$(3)
Files$() = "C:\test1.txt", "C:\test2.txt", "C:\test3.txt", "C:\test4.txt"
FOR f% = 0 TO DIM(Files$(),1)
infile$ = Files$(f%)
infile% = OPENIN(infile$)
IF infile%=0 ERROR 100, "Failed to open file " + infile$
tmpfile$ = @tmp$+"replace.txt"
tmpfile% = OPENOUT(tmpfile$)
WHILE NOT EOF#infile%
INPUT #infile%, a$
IF ASCa$=10 a$ = MID$(a$,2)
l% = LEN(FindThis$)
REPEAT
here% = INSTR(a$, FindThis$)
IF here% a$ = LEFT$(a$,here%-1) + ReplaceWith$ + MID$(a$,here%+l%)
UNTIL here% = 0
PRINT #tmpfile%, a$ : BPUT #tmpfile%,10
ENDWHILE
CLOSE #infile%
CLOSE #tmpfile%
OSCLI "DEL """ + infile$ + """"
OSCLI "REN """ + tmpfile$ + """ """ + infile$ + """"
NEXT
END</syntaxhighlight>
 
=={{header|C}}==
<langsyntaxhighlight Clang="c">#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
Line 151 ⟶ 244:
#include <string.h>
 
char * find_match(const char *buf, const char * buf_end, const char *pat, size_t len)
{
ptrdiff_t i;
Line 159 ⟶ 252:
if (start[i] != pat[i]) break;
 
if (i == len) return (char *)start;
start++;
}
Line 165 ⟶ 258:
}
 
int replace(const char *from, const char *to, const char *fname)
{
#define bail(msg) { warn(msg" '%s'", fname); goto done; }
Line 205 ⟶ 298:
int main()
{
const char *from = "Goodbye, London!";
const char *to = "Hello, New York!";
const char * files[] = { "test1.txt", "test2.txt", "test3.txt" };
int i;
 
Line 214 ⟶ 307:
 
return 0;
}</langsyntaxhighlight>
 
=={{header|C sharp}}==
<syntaxhighlight lang="csharp">
using System.Collections.Generic;
using System.IO;
 
class Program {
static void Main() {
var files = new List<string> {
"test1.txt",
"test2.txt"
};
foreach (string file in files) {
File.WriteAllText(file, File.ReadAllText(file).Replace("Goodbye London!", "Hello New York!"));
}
}
}
</syntaxhighlight>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <fstream>
#include <iterator>
#include <boost/regex.hpp>
Line 243 ⟶ 354:
}
return 0 ;
}</langsyntaxhighlight>
 
Modern C++ version:
<syntaxhighlight lang="cpp">#include <regex>
#include <fstream>
 
using namespace std;
using ist = istreambuf_iterator<char>;
using ost = ostreambuf_iterator<char>;
 
int main(){
auto from = "Goodbye London!", to = "Hello New York!";
for(auto filename : {"a.txt", "b.txt", "c.txt"}) {
ifstream infile {filename};
string content {ist {infile}, ist{}};
infile.close();
ofstream outfile {filename};
regex_replace(ost {outfile}, begin(content), end(content), regex {from}, to);
}
return 0;
}
</syntaxhighlight>
 
=={{header|Clojure}}==
<syntaxhighlight lang="clojure">(defn hello-goodbye [& more]
(doseq [file more]
(spit file (.replace (slurp file) "Goodbye London!" "Hello New York!"))))</syntaxhighlight>
 
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">
(defun hello-goodbye (files)
(labels ((replace-from-file (file)
(with-open-file (in file)
(loop for line = (read-line in nil)
while line do
(loop for index = (search "Goodbye London!" line)
while index do
(setf (subseq line index) "Hello New York!"))
collecting line)))
(write-lines-to-file (lines file)
(with-open-file (out file :direction :output :if-exists :overwrite)
(dolist (line lines)
(write-line line out))))
(replace-in-file (file)
(write-lines-to-file (replace-from-file file) file)))
(map nil #'replace-in-file files)))
</syntaxhighlight>
 
=={{header|D}}==
{{works with|D|2}}
<langsyntaxhighlight lang="d">import std.file, std.array;
 
void main() {
Line 254 ⟶ 411:
write(fn, replace(cast(string)read(fn), from, to));
}
}</langsyntaxhighlight>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| System.IoUtils}}
<syntaxhighlight lang="delphi">
program Globally_replace_text_in_several_files;
 
{$APPTYPE CONSOLE}
 
uses
System.SysUtils,
System.IoUtils;
 
procedure StringReplaceByFile(_old, _new: string; FileName: TFilename;
ReplaceFlags: TReplaceFlags = []); overload
var
Text: string;
begin
if not FileExists(FileName) then
exit;
Text := TFile.ReadAllText(FileName);
TFile.Delete(FileName);
TFile.WriteAllText(StringReplace(Text, _old, _new, ReplaceFlags), FileName);
end;
 
procedure StringReplaceByFile(_old, _new: string; FileNames: TArray<TFileName>;
ReplaceFlags: TReplaceFlags = []); overload;
begin
for var fn in FileNames do
StringReplaceByFile(_old, _new, fn);
end;
 
begin
StringReplaceByFile('Goodbye London!', 'Hello New York!', ['a.txt', 'b.txt', 'c.txt']);
end.</syntaxhighlight>
 
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
-module( globally_replace_text ).
 
-export( [in_files/3, main/1] ).
 
in_files( Old, New, Files ) when is_list(Old) ->
in_files( binary:list_to_bin(Old), binary:list_to_bin(New), Files );
in_files( Old, New, Files ) -> [replace_in_file(Old, New, X, file:read_file(X)) || X <- Files].
 
main( [Old, New | Files] ) -> in_files( Old, New, Files ).
 
 
 
replace_in_file( Old, New, File, {ok, Binary} ) ->
replace_in_file_return( File, file:write_file(File, binary:replace(Binary, Old, New, [global])) );
replace_in_file( _Old, _New, File, {error, Error} ) ->
io:fwrite( "Error: Could not read ~p: ~p~n", [File, Error] ),
error.
 
replace_in_file_return( _File, ok ) -> ok;
replace_in_file_return( File, {error, Error} ) ->
io:fwrite( "Error: Could not write ~p: ~p~n", [File, Error] ),
error.
</syntaxhighlight>
 
{{out}}
<pre>
macbook-pro:rosettacode bengt$ ls ?.txt
1.txt 2.txt
macbook-pro:rosettacode bengt$ more ?.txt
"Goodbye London!"
"Goodbye London!"
"Byebye London!" "Byebye London!" "Byebye London!"
...skipping...
"Goodbye London!"
"Byebye London!" "Byebye London!" "Byebye London!"
"Goodbye London!"
macbook-pro:rosettacode bengt$ escript globally_replace_text.erl "Goodbye London\!" "Hello New York\!" ?.txt
macbook-pro:rosettacode bengt$ more ?.txt
"Hello New York!"
"Hello New York!"
"Byebye London!" "Byebye London!" "Byebye London!"
...skipping...
"Hello New York!"
"Byebye London!" "Byebye London!" "Byebye London!"
"Hello New York!"
</pre>
 
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">open System.IO
 
[<EntryPoint>]
let main args =
let textFrom = "Goodbye London!"
let textTo = "Hello New York!"
for name in args do
let content = File.ReadAllText(name)
let newContent = content.Replace(textFrom, textTo)
if content <> newContent then
File.WriteAllText(name, newContent)
0</syntaxhighlight>
 
=={{header|Factor}}==
{{works with|Factor|0.99 2019-10-06}}
<syntaxhighlight lang="factor">USING: fry io.encodings.utf8 io.files kernel qw sequences
splitting ;
 
: global-replace ( files old new -- )
'[
[ utf8 file-contents _ _ replace ]
[ utf8 set-file-contents ] bi
] each ;
 
 
qw{ a.txt b.txt c.txt }
"Goodbye London!" "Hello New York!" global-replace</syntaxhighlight>
 
=={{header|Fortran}}==
This is in the style of F77 and solves the usual problem of "how long is a piece of string" by choosing a size that is surely long enough. Thus, CHARACTER*6666 ALINE. Fortran 2003 allows the alteration of the length of a character variable, but, unless there is a facility whereby in something like <code>READ(F,11) ALINE</code> the size of ALINE is adjusted to suit the record being read, this doesn't help much. The Q format code allows discovery of the length of a record as it is being read, and so only the required portion, ALINE(1:L), of an input record is placed and trailing spaces out to 6666 are not supplied nor need they be scanned. Thus an input record that has trailing spaces will have them preserved - unless the text replacement changes spaces...
 
The search is done by using the supplied INDEX function which alas rarely has an option to specify the starting point via an additional (optional?) parameter. So this must be done via <code>INDEX(ALINE(L1:L),THIS)</code> and then one must carefully consider offsets and the like while counting on fingers and becoming confused. On the other hand, ''it'' handles annoyances such as ALINE(L1:L) being shorter than THIS. The expression ALINE(L1:L) does ''not'' create a new string variable by copying the specified text, it works (or should work!) via offsets into ALINE. Similarly, there is no attempt to concatenate an output string to write in one go as that too would involve copying text about. Though WRITE statements involve no small overhead in themselves. Although if LEN(THIS) = LEN(THAT) as is the case in the example task an alter-in-place could be used and ALINE(1:L) be written out in one go, the more general approach is used of writing text up to the start of a match, writing out the replacement THAT, and scanning beyond the match for the next text until the tail end.
 
The file to be altered cannot be changed "in-place", as by writing back an altered record even if the text replacement does not involve a change in length because such a facility is not available for text files that are read and written sequentially only. More accomplished file systems may well offer varying-length records with update possible even of longer or shorter new versions but standard Fortran does not demand such facilities. So, the altered content has to be written to a temporary file (or perhaps could be held in a capacious memory) which is then read back to overwrite the original file. It would be safer to rename the original file and write to a new version, but Fortran typically does not have access to any file renaming facilities and the task calls for an overwrite anyway. So, overwrite it is, which is actually a file delete followed by a write.
 
Once equipped with a subroutine that applies a specified change to a named disc file, there is no difficulty in invoking it for a horde of disc files. A more civilised routine might make reports about the files assaulted and the number of changes, and also be prepared to report various oddities such as a file being available but not for WRITE. It is for this reason that the source file is opened with READWRITE even though it at that stage is only going to be read from.<syntaxhighlight lang="fortran"> SUBROUTINE FILEHACK(FNAME,THIS,THAT) !Attacks a file!
CHARACTER*(*) FNAME !The name of the file, presumed to contain text.
CHARACTER*(*) THIS !The text sought in each record.
CHARACTER*(*) THAT !Its replacement, should it be found.
INTEGER F,T !Mnemonics for file unit numbers.
PARAMETER (F=66,T=67) !These should do.
INTEGER L !A length
CHARACTER*6666 ALINE !Surely sufficient?
LOGICAL AHIT !Could count them, but no report is called for.
INQUIRE(FILE = FNAME, EXIST = AHIT) !This mishap is frequent, so attend to it.
IF (.NOT.AHIT) RETURN !Nothing can be done!
OPEN (F,FILE=FNAME,STATUS="OLD",ACTION="READWRITE") !Grab the source file.
OPEN (T,STATUS="SCRATCH") !Request a temporary file.
AHIT = .FALSE. !None found so far.
Chew through the input, replacing THIS by THAT while writing to the temporary file..
10 READ (F,11,END = 20) L,ALINE(1:MIN(L,LEN(ALINE))) !Grab a record.
IF (L.GT.LEN(ALINE)) STOP "Monster record!" !Perhaps unmanageable.
11 FORMAT (Q,A) !Obviously, Q = length of characters unread in the record.
L1 = 1 !Start at the start.
12 L2 = INDEX(ALINE(L1:L),THIS) !Look from L1 onwards.
IF (L2.LE.0) THEN !A hit?
WRITE (T,13) ALINE(L1:L) !No. Finish with the remainder of the line.
13 FORMAT (A) !Thus finishing the output line.
GO TO 10 !And try for the next record.
END IF !So much for not finding THIS.
14 L2 = L1 + L2 - 2 !Otherwise, THIS is found, starting at L1.
WRITE (T,15) ALINE(L1:L2) !So roll the text up to the match, possibly none.
15 FORMAT (A,$) !But not ending the record.
WRITE (T,15) THAT !Because THIS is replaced by THAT.
AHIT = .TRUE. !And we've found at least one match.
L1 = L2 + LEN(THIS) + 1 !Finger the first character beyond the matching THIS.
IF (L - L1 + 1 .GE. LEN(THIS)) GO TO 12 !Might another search succeed?
WRITE (T,13) ALINE(L1:L) !Nope. Finish the line with the tail end.
GO TO 10 !And try for another record.
Copy the temporary file back over the source file. Hope for no mishap and data loss!
20 IF (AHIT) THEN !If there were no hits, there is nothing to do.
CLOSE (F) !Oh well.
REWIND T !Go back to the start.
OPEN (F,FILE="new"//FNAME,STATUS = "REPLACE",ACTION = "WRITE") !Overwrite...
21 READ (T,11,END = 22) L,ALINE(1:MIN(L,LEN(ALINE))) !Grab a line.
IF (L.GT.LEN(ALINE)) STOP "Monster changed record!" !Once you start checking...
WRITE (F,13) ALINE(1:L) !In case LEN(THAT) > LEN(THIS)
GO TO 21 !Go grab the next line.
END IF !So much for the replacement of the file.
22 CLOSE(T) !Finished: it will vanish.
CLOSE(F) !Hopefully, the buffers will be written.
END !So much for that.
 
PROGRAM ATTACK
INTEGER N
PARAMETER (N = 6) !More than one, anyway.
CHARACTER*48 VICTIM(N) !Alternatively, the file names could be read from a file
DATA VICTIM/ !Along with the target and replacement texts in each case.
1 "StaffStory.txt",
2 "Accounts.dat",
3 "TravelAgent.txt",
4 "RemovalFirm.dat",
5 "Addresses.txt",
6 "SongLyrics.txt"/ !Invention flags.
 
DO I = 1,N !So, step through the list.
CALL FILEHACK(VICTIM(I),"Goodbye London!","Hello New York!") !One by one.
END DO !On to the next.
 
END</syntaxhighlight>
 
=={{header|FreeBASIC}}==
{{trans|BASIC}}
<syntaxhighlight lang="freebasic">Const matchtext = "Goodbye London!"
Const repltext = "Hello New York!"
Const matchlen = Len(matchtext)
 
Dim As Integer x, L0 = 1
dim as string filespec, linein
 
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)
Else
Exit Do
End If
Loop
Close
Open filespec For Output As 1
Print #1, linein;
Close
filespec = Dir
Wend
L0 += 1
Wend</syntaxhighlight>
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
 
void local fn GloballyCreateAndReplaceFileText
NSUInteger i
CFURLRef url
CFMutableArrayRef mutURL = fn MutableArrayNew
CFArrayRef fileNames = @[@"file1", @"file2", @"file3"]
CFStringRef fileContentStr
CFStringRef originalText = @"Goodbye London!"
CFStringRef replacementText = @"Hello New York!"
for i = 0 to len(fileNames) - 1
CFURLRef desktopURL = fn FileManagerURLForDirectory( NSDesktopDirectory, NSUserDomainMask )
url = fn URLByAppendingPathComponent( desktopURL, fileNames[i] )
url = fn URLByAppendingPathExtension( url, @"txt" )
CFStringRef fullText = fn StringWithFormat( @"%@ What an interesting city.", originalText )
fn StringWriteToURL( fullText, url, YES, NSUTF8StringEncoding, NULL )
MutableArrayAddObject( mutURL, url )
next
NSLog( @"Original text:" )
for i = 0 to len(mutURL) - 1
fileContentStr = fn StringWithContentsOfURL( mutURL[i], NSUTF8StringEncoding, NULL )
NSLog( @"Contents at: %@ = %@", fn URLPath( mutURL[i] ), fileContentStr )
CFStringRef modifiedText = fn StringByReplacingOccurrencesOfString( fileContentStr, originalText, replacementText )
fn StringWriteToURL( modifiedText, mutURL[i], YES, NSUTF8StringEncoding, NULL )
next
NSLog( @"\nReplacement text:" )
for i = 0 to len(mutURL) - 1
fileContentStr = fn StringWithContentsOfURL( mutURL[i], NSUTF8StringEncoding, NULL )
NSLog( @"Contents at: %@ = %@", fn URLPath( mutURL[i] ), fileContentStr )
next
end fn
 
fn GloballyCreateAndReplaceFileText
 
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
Original text:
Contents at: /Users/ken/Desktop/file1.txt = Goodbye London! What an interesting city.
Contents at: /Users/ken/Desktop/file2.txt = Goodbye London! What an interesting city.
Contents at: /Users/ken/Desktop/file3.txt = Goodbye London! What an interesting city.
 
Replacement text:
Contents at: /Users/ken/Desktop/file1.txt = Hello New York! What an interesting city.
Contents at: /Users/ken/Desktop/file2.txt = Hello New York! What an interesting city.
Contents at: /Users/ken/Desktop/file3.txt = Hello New York! What an interesting city.
</pre>
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 306 ⟶ 735:
_, err = f.WriteAt(r, 0)
return
}</langsyntaxhighlight>
 
=={{header|Haskell}}==
The module Data.List provides some useful functions: tails (constructs substrings dropping elements from the head of the list), isPrefixOf (checks if a string matches the beginning of another one) and elemIndices (gets the list indices of all elements matching a value).
This code doesn't rewrite the files, it just returns the changes made to the contents of the files.
<syntaxhighlight lang="haskell">import Data.List (tails, elemIndices, isPrefixOf)
 
replace :: String -> String -> String -> String
replace [] _ xs = xs
replace _ [] xs = xs
replace _ _ [] = []
replace a b xs = replAll
where
-- make substrings, dropping one element each time
xtails = tails xs
-- what substrings begin with the string to replace?
-- get their indices
matches = elemIndices True $ map (isPrefixOf a) xtails
-- replace one occurrence
repl ys n = take n ys ++ b ++ drop (n + length b) ys
-- replace all occurrences consecutively
replAll = foldl repl xs matches
 
replaceInFiles a1 a2 files = do
f <- mapM readFile files
return $ map (replace a1 a2) f
</syntaxhighlight>
This other version is more effective because it processes the string more lazily, replacing the text as it consumes the input string (the previous version was stricter because of "matches" traversing the whole list; that would force the whole string into memory, which could cause the system to run out of memory with large text files).
<syntaxhighlight lang="haskell">replace :: Eq a => [a] -> [a] -> [a] -> [a]
replace a b = go
where
w = length a
go [] = []
go xxs@(x : xs)
| a `isPrefixOf` xxs = b <> go (drop w xxs)
| otherwise = x : go xs</syntaxhighlight>
 
and with different library imports, we could also write things like:
<syntaxhighlight lang="haskell">import Data.List (intercalate)
import Data.List.Split (splitOn)
 
replace :: String -> String -> String -> String
replace a b = intercalate b . splitOn a</syntaxhighlight>
 
 
'''Example:'''
<pre>
File "t1.txt" contains: "Goodbye London! This is text 1."
File "t2.txt" contains: "This is text 2. Goodbye London! Now we repeat: Goodbye London! And that's all."
 
replaceInFiles "Goodbye London!" "Hello New York!" ["t1.txt", "t2.txt"]
</pre>
'''Output:'''
<pre>
["Hello New York! This is text 1.\n","This is text 2. Hello New York! Now we repeat: Hello New York! And that's all.\n"]
</pre>
 
=={{header|Icon}} and {{header|Unicon}}==
This example uses the Unicon stat function. It can be rewritten for Icon to aggregate the file in a reads loop.
<langsyntaxhighlight Iconlang="icon">procedure main()
globalrepl("Goodbye London","Hello New York","a.txt","b.txt") # variable args for files
end
Line 324 ⟶ 808:
end
 
link strings # for replace</langsyntaxhighlight>
 
{{libheader|Icon Programming Library}}
Line 333 ⟶ 817:
If <code>files</code> is a variable with the desired list of file names:
 
<langsyntaxhighlight lang="j">require'strings'
(1!:2~rplc&('Goodbye London!';'Hello New York!')@(1!:1))"0 files</langsyntaxhighlight>
 
=={{header|Java}}==
Minimalistic version, assumes default encoding.
{{works with|Java|7}}
<syntaxhighlight lang="java">import java.io.*;
import java.nio.file.*;
 
public class GloballyReplaceText {
 
public static void main(String[] args) throws IOException {
 
for (String fn : new String[]{"test1.txt", "test2.txt"}) {
String s = new String(Files.readAllBytes(Paths.get(fn)));
s = s.replace("Goodbye London!", "Hello New York!");
try (FileWriter fw = new FileWriter(fn)) {
fw.write(s);
}
}
}
}</syntaxhighlight>
 
In Java 11 the body could be shortened to:
<syntaxhighlight lang="java">
for (String fn : List.of("file1.txt","file2.txt")) {
Path path = Path.of(fn);
Files.writeString(path,
Files.readString(path).replace("Goodbye London!", "Hello New York!"));
}
</syntaxhighlight>
 
=={{header|jq}}==
{{works with|jq|1.5}}
jq delegates filename manipulation to the shell. For simplicity, in the following we assume the availability of `sponge` to simplify the mechanics of editing a file "in-place".
<syntaxhighlight lang="bash">for file
do
jq -Rr 'gsub($from; $to)' --arg from 'Goodbye London!' --arg to 'Hello New York!' "$file" |
sponge "$file"
done</syntaxhighlight>
 
The jq filter used above is `gsub/2`, which however is designed for regular expressions. Here is a string-oriented alternative:
<syntaxhighlight lang="jq">def gsubst($from; $to):
($from | length) as $len
| def g:
index($from) as $ix
| if $ix then .[:$ix] + $to + (.[($ix+$len):] | g) else . end;
g;</syntaxhighlight>
 
=={{header|Jsish}}==
'''For the demo, the code does not overwrite the samples, but creates a .new file.'''
<syntaxhighlight lang="javascript">/* Global replace in Jsish */
if (console.args.length == 0) {
console.args.push('-');
}
 
/* For each file, globally replace "Goodbye London!" with "Hello New York!" */
var fn, data, changed;
for (fn of console.args) {
/* No args, or an argument of - uses "stdin" (a special Channel name) */
if (fn == 'stdin') fn = './stdin';
if (fn == '-') fn = 'stdin';
try {
data = File.read(fn);
/* Jsi supports the m multiline regexp flag */
changed = data.replace(/Goodbye London!/gm, 'Hello New York!');
if (changed != data) {
if (fn == 'stdin') fn = 'stdout'; else fn += '.new';
var cnt = File.write(fn, changed);
puts(fn + ":" + cnt, 'updated');
}
} catch(err) { puts(err, 'processing', fn); }
}</syntaxhighlight>
 
To meet the task specification, change
 
<syntaxhighlight lang="javascript">if (fn == 'stdin') fn = 'stdout'; else fn += '.new';</syntaxhighlight>
 
to
 
<syntaxhighlight lang="javascript">if (fn == 'stdin') fn = 'stdout';</syntaxhighlight>
 
removing the else clause. The code will then overwrite originals.
{{out}}
<pre>prompt$ cat one
Goodbye London! it was the slice.
Goodbye London, should still be here
And a little more Goodbye London! New York!
 
prompt$ jsish global-replace.jsi - <one
Hello New York! it was the slice.
Goodbye London, should still be here
And a little more Hello New York! New York!
stdout:115 updated</pre>
 
=={{header|Julia}}==
We will use Julia's built-in Perl-compatible [http://docs.julialang.org/en/latest/manual/strings/#regular-expressions regular-expressions]. Although we could read in the files line by line, it is simpler and probably faster to just read the whole file into memory (as text files are likely to fit into memory on modern computers).
<syntaxhighlight lang="julia">filenames = ["f1.txt", "f2.txt"]
for filename in filenames
txt = read(filename, String)
open(filename, "w") do f
write(f, replace(txt, "Goodbye London!" => "Hello New York!"))
end
end</syntaxhighlight>
 
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.2.0
 
import java.io.File
 
fun main(args: Array<String>) {
val files = arrayOf("file1.txt", "file2.txt")
for (file in files) {
val f = File(file)
var text = f.readText()
println(text)
text = text.replace("Goodbye London!", "Hello New York!")
f.writeText(text)
println(f.readText())
}
}</syntaxhighlight>
 
{{out}}
<pre>
File1 contains "Goodbye London!"
 
File1 contains "Hello New York!"
 
File2 contains "Goodbye London!"
 
File2 contains "Hello New York!"
</pre>
 
=={{header|Lasso}}==
<syntaxhighlight lang="lasso">#!/usr/bin/lasso9
 
local(files = array('f1.txt', 'f2.txt'))
 
with filename in #files
let file = file(#filename)
let content = #file -> readbytes
do {
#file -> dowithclose => {
#content -> replace('Goodbye London!', 'Hello New York!')
#file -> opentruncate
#file -> writebytes(#content)
}
}</syntaxhighlight>
 
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
<lang lb>
nomainwin
 
Line 375 ⟶ 1,004:
end if
end function
</syntaxhighlight>
</lang>
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">filenames = { "f1.txt", "f2.txt" }
 
for _, fn in pairs( filenames ) do
Line 389 ⟶ 1,018:
fp:write( str )
fp:close()
end</langsyntaxhighlight>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">listOfFiles = {"a.txt", "b.txt", "c.txt"};
Do[
filename = listOfFiles[[i]];
filetext = Import[filename, "Text"];
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]</syntaxhighlight>
File b.txt before the code is run:
<pre>second file for the Globally replace text in several files problem.
Goodbye London!
Goodbye London!
Bye bye London!
Bye bye London! Bye bye London!</pre>
File b.txt after the code is run:
<pre>second file for the Globally replace text in several files problem.
Hello New York!
Hello New York!
Bye bye London!
Bye bye London! Bye bye London!
</pre>
 
=={{header|newLISP}}==
{{works with|newLisp|10.7.5}}
<syntaxhighlight lang="newlisp">
(define (replace-in-file filename this bythat)
(set 'content (read-file filename))
(when (string? content)
(replace this content bythat)
(write-file filename content)
)
)
 
(set 'files '("a.txt" "b.txt" "c.txt" "missing"))
(dolist (fname files)
(replace-in-file fname "Goodbye London!" "Hello New York!")
)
 
(exit)
</syntaxhighlight>
 
=={{header|Nim}}==
<syntaxhighlight lang="nim">import strutils
 
let fr = "Goodbye London!"
let to = "Hello, New York!"
 
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)</syntaxhighlight>
 
=={{header|Objeck}}==
<syntaxhighlight lang="objeck">class ReplaceAll {
function : Main(args : String[]) ~ Nil {
files := ["text1.txt", "text2.txt"];
each(f : files) {
input := System.IO.File.FileReader->ReadFile(files[f]);
output := input->ReplaceAll("Goodbye London!", "Hello New York!");
System.IO.File.FileWriter->WriteFile(files[f], output)->PrintLine();
};
}
}</syntaxhighlight>
 
=={{header|OpenEdge/Progress}}==
<langsyntaxhighlight lang="progress">FUNCTION replaceText RETURNS LOGICAL (
i_cfile_list AS CHAR,
i_cfrom AS CHAR,
Line 415 ⟶ 1,104:
"Goodbye London!",
"Hello New York!"
).</langsyntaxhighlight>
 
=={{header|Pascal}}==
{{works with|Free_Pascal}}
<langsyntaxhighlight lang="pascal">Program StringReplace;
 
uses
Line 443 ⟶ 1,132:
AllText.Destroy;
end;
end.</langsyntaxhighlight>
 
=={{header|Perl}}==
<langsyntaxhighlight lang="bash">perl -pi -e "s/Goodbye London\!/Hello New York\!/g;" a.txt b.txt c.txt</langsyntaxhighlight>
 
=={{header|Phix}}==
ctrace.out was just a file that happened to be handy, obviously you'd have to provide your own file list.<br>
as hinted, you could probably improve on the error handling.<br>
get_text is deliberately limited to 1GB, for larger files use a temporary file, a loop of gets/puts, and delete_file/rename_file at the end.
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- file i/o</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">global_replace</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">file_list</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">file_list</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">filename</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">file_list</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #000000;">filename</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"rb"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">fn</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">9</span><span style="color: #0000FF;">/</span><span style="color: #000000;">0</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span> <span style="color: #000080;font-style:italic;">-- message/retry?</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">text</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_text</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">text</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">text</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">r</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #000000;">filename</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"wb"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">text</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">file_list</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"ctrace.out"</span><span style="color: #0000FF;">}</span>
<span style="color: #000000;">global_replace</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Goodbye London!"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Hello New York!"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">file_list</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="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!") ) ) ) )</langsyntaxhighlight>
 
=={{header|PowerBASIC}}==
{{trans|BASIC}}
<langsyntaxhighlight lang="powerbasic">$matchtext = "Goodbye London!"
$repltext = "Hello New York!"
 
Line 480 ⟶ 1,193:
INCR L0
WEND
END FUNCTION</langsyntaxhighlight>
 
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
$listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
$new = 'Hello New York!'
foreach($file in $listfiles) {
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
</syntaxhighlight>
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">Procedure GRTISF(List File$(), Find$, Replace$)
Protected Line$, Out$, OutFile$, i
ForEach File$()
Line 514 ⟶ 1,237:
EndIf
Next
EndProcedure</langsyntaxhighlight>
Implementation
<pre>NewList Xyz$()
Line 526 ⟶ 1,249:
From [http://docs.python.org/library/fileinput.html Python docs]. (Note: in-place editing does not work for MS-DOS 8+3 filesystems.).
 
<langsyntaxhighlight lang="python">import fileinput
 
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
</syntaxhighlight>
</lang>
 
=={{header|Racket}}==
Code wrapped in a convenient script:
<syntaxhighlight lang="racket">
#!/usr/bin/env racket
#lang racket
 
(define from-string #f)
(define to-string #f)
 
(command-line
#:once-each
[("-f") from "Text to remove" (set! from-string from)]
[("-t") to "Text to put instead" (set! to-string to)]
#:args files
(unless from-string (error "No `from' string specified"))
(unless to-string (error "No `to' string specified"))
(when (null? files) (error "No files given"))
(define from-rx (regexp (regexp-quote from-string)))
(for ([file files])
(printf "Editing ~a..." file) (flush-output)
(define text1 (file->string file))
(define text2 (regexp-replace* from-rx text1 to-string))
(if (equal? text1 text2)
(printf " no change\n")
(begin (display-to-file text2 file #:exists 'replace)
(printf " modified copy saved in place\n")))))
</syntaxhighlight>
Sample run:
<pre>
$ ./replace -h
replace [ <option> ... ] [<files>] ...
where <option> is one of
-f <from> : Text to remove
-t <to> : Text to put instead
--help, -h : Show this help
-- : Do not treat any remaining argument as a switch (at this level)
Multiple single-letter switches can be combined after one `-'; for
example: `-h-' is the same as `-h --'
$ ./replace -f "Goodbye London!" "Hello New York!" file*
Editing file1... no change
Editing file2... modified copy saved in place
Editing file3... modified copy saved in place
</pre>
 
=={{header|Raku}}==
(formerly Perl 6)
 
Current Raku implementations do not yet support the -i flag for editing files in place, so we roll our own (rather unsafe) version:
 
<syntaxhighlight lang="raku" line>slurp($_).subst('Goodbye London!', 'Hello New York!', :g) ==> spurt($_)
for <a.txt b.txt c.txt>;</syntaxhighlight>
 
=={{header|Red}}==
<syntaxhighlight lang="red">>> f: request-file
>> str: read f
>> replace/all str "Goodbye London!" "Hello New York!"
>> write f str</syntaxhighlight>
 
=={{header|REXX}}==
===version 1===
This example works under "DOS" and/or "DOS" under Microsoft Windows.
<br><br>File names that contain blanks should have their blanks replaced with commas.
<syntaxhighlight lang="rexx">/*REXX program reads the files specified and globally replaces a string. */
old= "Goodbye London!" /*the old text to be replaced. */
new= "Hello New York!" /* " new " used for replacement. */
parse arg fileList /*obtain required list of files from CL*/
#= words(fileList) /*the number of files in the file list.*/
 
do f=1 for #; fn= translate( word(fileList, f), , ','); say; say
say '──────── file is being read: ' fn " ("f 'out of' # "files)."
call linein fn,1,0 /*position the file for input. */
changes= 0 /*the number of changes in file so far.*/
do rec=0 while lines(fn)\==0 /*read a file (if it exists). */
@.rec= linein(fn) /*read a record (line) from the file. */
if pos(old, @.rec)==0 then iterate /*Anything to change? No, then skip. */
changes= changes + 1 /*flag that file contents have changed.*/
@.rec= changestr(old, @.rec, new) /*change the @.rec record, old ──► new.*/
end /*rec*/
 
say '──────── file has been read: ' fn", with " rec 'records.'
if changes==0 then do; say '──────── file not changed: ' fn; iterate; end
call lineout fn,,1 /*position file for output at 1st line.*/
say '──────── file being changed: ' fn
 
do r=0 for rec; call lineout fn, @.r /*re─write the contents of the file. */
end /*r*/
 
say '──────── file was changed: ' fn " with" changes 'lines changed.'
end /*f*/ /*stick a fork in it, we're all done. */</syntaxhighlight>
Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].
<br><br>
{{out|output|text=&nbsp; when using the input (list of files) of: &nbsp; &nbsp; <tt> one.txt &nbsp; two.txt </tt>}}
<pre>
──────── file is being read: one.txt (1 out of 2 files).
──────── file has been read: one.txt, with 13 records.
──────── file being changed: one.txt
──────── file was changed: one.txt with 2 lines changed.
 
 
──────── file is being read: two.txt (2 out of 2 files).
──────── file has been read: two.txt, with 59 records.
──────── file being changed: two.txt
──────── file was changed: two.txt with 6 lines changed.
</pre>
 
===Version 2===
considering file ids that contain blanks
<syntaxhighlight lang="rexx">/* REXX ***************************************************************
* Copy all files *.txt to *.rpl
* replacing all occurrences of old by new
* Execute in the directory containing the files to be processed
* 16.01.2013 Walter Pachl
* ...if file names contain blanks
**********************************************************************/
Parse Arg a
If a='?' Then Do
Do i=2 To 5
Say substr(sourceline(i),3)
End
Exit
End
'dir *.rpl'
Say 'May I erase *.rpl?'
Parse Upper Pull answer
If answer='Y' | answer='J' Then
'erase *.rpl'
Else Do
Say 'Giving up..'
Exit
End
old='Goodbye London!'
new='Hello New York!'
dir='dir.dir'
'dir *.* >' dir
Do While lines(dir)>0
Parse Value linein(dir) With 37 f
Select
When f='' |,
left(f,1)='.' |,
pos(' Bytes',f)>0 Then Iterate
When right(f,4)='.txt' Then
Call replace
Otherwise
Say left(f,50) 'not eligible for replacing'
End
End
Exit
 
replace:
/* REXX ***************************************************************
* Copy a file fn.txt to fn.rpl
* replacing all occurrences of old by new
**********************************************************************/
oid=fn(f)'.rpl'
cnt.=0
Do ii=1 By 1 While lines(f)>0
l=linein(f)
ol=repl(l,new,old)
Call lineout oid,ol
End
Call lineout f
Call lineout oid
Select
When cnt.0changes=0 Then Do
'erase' oid
Say left(f,50) 'no changes'
End
When cnt.0changes=1 Then
Say left(f,50) '1 change'
Otherwise
Say left(f '->' oid,50) cnt.0changes 'changes'
End
Return
 
fn: Procedure
/* REXX ***************************************************************
* Get the file name of a file id
**********************************************************************/
parse Arg fid
Parse Var fid fn '.' ft
Return fn
 
repl: Procedure Expose cnt.
/* REXX ***************************************************************
* Replace an old string by a new one
**********************************************************************/
Parse Arg s,new,old
ol=''
Do Until p=0
p=pos(old,s)
If p>0 Then Do
ol=ol||left(s,p-1)||new
s=substr(s,p+length(old))
cnt.0changes=cnt.0changes+1
End
Else
ol=ol||s
End
Return ol</syntaxhighlight>
Sample output:
<pre>
Datenträger in Laufwerk Z: ist H
Volumeseriennummer: FE17-3A89
 
Verzeichnis von Z:\glr
 
16.01.2013 09:55 283 input.rpl
16.01.2013 09:55 352 input2.rpl
16.01.2013 09:55 283 input file.rpl
3 Datei(en), 918 Bytes
0 Verzeichnis(se), 3.993.468.928 Bytes frei
May I erase *.rpl?
----> here I entered y
input.txt -> input.rpl 1 change
input.nix not eligible for replacing
input2.txt -> input2.rpl 4 changes
dir.dir not eligible for replacing
input file.txt -> input file.rpl 1 change
input3.txt no changes
</pre>
 
=={{header|Ring}}==
<syntaxhighlight lang="ring">
filenames = ["ReadMe.txt", "ReadMe2.txt"]
 
for fn in filenames
fp = fopen(fn,"r")
str = fread(fp,getFileSize(fp))
str = substr(str, "Greetings", "Hello")
fclose(fp)
 
fp = fopen(fn,"w")
fwrite(fp, str)
fclose(fp)
next
 
func getFileSize fp
C_FILESTART = 0
C_FILEEND = 2
fseek(fp,0,C_FILEEND)
nFileSize = ftell(fp)
fseek(fp,0,C_FILESTART)
return nFileSize
</syntaxhighlight>
 
=={{header|Ruby}}==
Line 539 ⟶ 1,507:
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang="runbasic">file$(1) ="data1.txt"
file$(2) ="data2.txt"
file$(3) ="data3.txt"
Line 571 ⟶ 1,539:
i = i + 1
WEND
END FUNCTION</langsyntaxhighlight>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">
//! Author: Rahul Sharma
//! Github: <https://github.com/creativcoder>
 
use std::fs::File;
use std::fs::OpenOptions;
use std::io::BufRead;
use std::io::BufReader;
use std::io::BufWriter;
use std::io::Write;
 
fn main() {
// opens file for writing replaced lines
let out_fd = OpenOptions::new()
.write(true)
.create(true)
.open("resources/output.txt");
 
// defining a closure write_line
let write_line = |line: &str| match out_fd {
Ok(ref v) => {
let mut writer = BufWriter::new(v);
writer.write_all(line.as_bytes()).unwrap();
}
Err(ref e) => {
println!("Error:{}", e);
}
};
// read input file
match File::open("resources/paragraph.txt") {
Ok(handle) => {
let mut reader = BufReader::new(handle);
let mut line = String::new();
// read the first line
reader.read_line(&mut line).unwrap();
// loop until line end
while line.trim() != "" {
let mut replaced_line = line.trim().replace("Goodbye London!", "Hello New York!");
replaced_line += "\n";
write_line(&replaced_line[..]);
line.clear();
reader.read_line(&mut line).unwrap();
}
}
Err(e) => println!("Error:{}", e),
}
}
</syntaxhighlight>
{{out}}
<pre>
</pre>
 
=={{header|Scala}}==
<syntaxhighlight lang="scala">import java.io.{File, PrintWriter}
 
object GloballyReplaceText extends App {
 
val (charsetName, fileNames) = ("UTF8", Seq("file1.txt", "file2.txt"))
for (fileHandle <- fileNames.map(new File(_)))
new PrintWriter(fileHandle, charsetName) {
print(scala.io.Source.fromFile(fileHandle, charsetName).mkString
.replace("Goodbye London!", "Hello New York!"))
close()
}
 
}</syntaxhighlight>
 
=={{header|Sed}}==
{{works with|GNU Sed}}
<syntaxhighlight lang="bash">sed -i 's/Goodbye London!/Hello New York!/g' a.txt b.txt c.txt</syntaxhighlight>
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "getf.s7i";
Line 587 ⟶ 1,627:
putf(fileName, content);
end for;
end func;</langsyntaxhighlight>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var names = %w(
a.txt
b.txt
c.txt
)
 
names.map{ File(_) }.each { |file|
say file.edit { |line|
line.gsub("Goodbye London!", "Hello New York!")
}
}</syntaxhighlight>
 
=={{header|Tcl}}==
{{tcllib|fileutil}}
<langsyntaxhighlight lang="tcl">package require Tcl 8.5
package require fileutil
 
Line 605 ⟶ 1,658:
foreach filename $fileList {
fileutil::updateInPlace $filename $replacementCmd
}</langsyntaxhighlight>
 
 
=={{header|Transd}}==
<syntaxhighlight lang="scheme">#lang transd
 
MainModule: {
_start: (λ
(with files ["a.txt" "b.txt" "c.txt"] fs FileStream()
(for f in files do
(open-r fs f)
(with s (replace (read-text fs)
"Goodbye London!" "Hello New York!")
(close fs)
(open-w fs f)
(write fs (to-bytes s) (size s)))))
)
}</syntaxhighlight>
 
=={{header|TUSCRIPT}}==
<langsyntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT
files="a.txt'b.txt'c.txt"
Line 629 ⟶ 1,700:
ENDLOOP
ERROR/STOP DELETE ("scratch")
</syntaxhighlight>
</lang>
 
=={{header|TXR}}==
 
===Extraction Language===
Another use of a screwdriver as a hammer.
 
<syntaxhighlight lang="txr">@(next :args)
The dummy empty output at the end serves a dual purpose. Firstly, without argument clauses following it, the <code>@(next `!mv ...`)</code> will not actually happen (lazy evaluation!). Secondly, if a <code>txr</code> script performs no output on standard output, the default action of dumping variable bindings kicks in.
@(repeat)
 
<lang txr>@(next :args)
@(collect)
@file
@(next `@file`)
Line 646 ⟶ 1,715:
@(rep)@{notmatch}Hello, New York!@(end)@tail
@(end)
@(nextdo `!mv@(rename-path `@file.tmp` @file`))
@(end)</syntaxhighlight>
@(output)
@(end)
@(end)</lang>
Run:
<pre>$ cat foo.txt
Line 671 ⟶ 1,738:
txr: unhandled exception of type file_error:
txr: could not open foo.txt.tmp (error 13/Permission denied)
false</pre>
 
===TXR Lisp===
 
<syntaxhighlight lang="txrlisp">(each ((fname *args*))
(let* ((infile (open-file fname))
(outfile (open-file `@fname.tmp` "w"))
(content (get-string infile))
(edited (regsub #/Goodbye, London/ "Hello, New York" content)))
(put-string edited outfile)
(rename-path `@fname.tmp` fname)))</syntaxhighlight>
 
=={{header|UNIX Shell}}==
{{works with|bash}}
<syntaxhighlight lang="bash">replace() {
local search=$1 replace=$2
local file lines line
shift 2
for file in "$@"; do
lines=()
while IFS= read -r line; do
lines+=( "${line//$search/$replace}" )
done < "$file"
printf "%s\n" "${lines[@]}" > "$file"
done
}
replace "Goodbye London!" "Hello New York!" a.txt b.txt c.txt</syntaxhighlight>
 
{{works with|ksh93}}
<syntaxhighlight lang="bash">function replace {
typeset search=$1 replace=$2
typeset file lines line
shift 2
for file in "$@"; do
lines=()
while IFS= read -r line; do
lines+=( "${line//$search/$replace}" )
done < "$file"
printf "%s\n" "${lines[@]}" > "$file"
done
}
replace "Goodbye London!" "Hello New York!" a.txt b.txt c.txt</syntaxhighlight>
 
=={{header|VBScript}}==
{{works with|Windows Script Host|*}}
<syntaxhighlight lang="vbscript">
Const ForReading = 1
Const ForWriting = 2
 
strFiles = Array("test1.txt", "test2.txt", "test3.txt")
 
With CreateObject("Scripting.FileSystemObject")
For i = 0 To UBound(strFiles)
strText = .OpenTextFile(strFiles(i), ForReading).ReadAll()
With .OpenTextFile(strFiles(i), ForWriting)
.Write Replace(strText, "Goodbye London!", "Hello New York!")
.Close
End With
Next
End With
</syntaxhighlight>
 
=={{header|Vedit macro language}}==
The list of files is in file "files.lst" which is expected to be in current directory.
<syntaxhighlight lang="vedit">File_Open("files.lst") // list of files to process
#20 = Reg_Free // text register for filename
 
While(!At_EOF) {
Reg_Copy_Block(#20, Cur_Pos, EOL_Pos)
File_Open(@(#20))
Replace("Goodbye London!", "Hello New York!", BEGIN+ALL+NOERR)
Buf_Close(NOMSG)
Line(1, ERRBREAK)
}
 
Reg_Empty(#20) // Cleanup
Buf_Quit(OK)</syntaxhighlight>
 
=={{header|Wren}}==
<syntaxhighlight lang="wren">import "io" for File
 
var files = ["file1.txt", "file2.txt"]
for (file in files) {
var text = File.read(file)
System.print("%(file) contains: %(text)")
text = text.replace("Goodbye London!", "Hello New York!")
File.create(file) { |f| // overwrites existing file
f.writeBytes(text)
}
System.print("%(file) now contains: %(File.read(file))")
}</syntaxhighlight>
 
{{out}}
<pre>
file1.txt contains: "Goodbye London!"
 
file1.txt now contains: "Hello New York!"
 
file2.txt contains: "Goodbye London!"
 
file2.txt now contains: "Hello New York!"
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">include c:\cxpl\codes; \intrinsic 'code' declarations
string 0; \use zero-terminated strings
 
func StrLen(A); \Return number of characters in an ASCIIZ string
char A;
int I;
for I:= 0 to -1>>1-1 do
if A(I) = 0 then return I;
 
func StrFind(A, B); \Search for ASCIIZ string A in string B
\Returns address of first occurrence of string A in B, or zero if A is not found
char A, B; \strings to be compared
int LA, LB, I, J;
[LA:= StrLen(A);
LB:= StrLen(B);
for I:= 0 to LB-LA do
[for J:= 0 to LA-1 do
if A(J) # B(J+I) then J:= LA+1;
if J = LA then return B+I; \found
];
return 0;
];
 
proc ReplaceText(FileName); \replace text in specified file
char FileName;
char Str(1_000_000), Hello, Bye, Pointer;
int Handle, I, C;
[Handle:= FOpen(FileName, 0); \get handle for input file
FSet(Handle, ^I); \set device 3 input to file handle
OpenI(3); \initialize buffer pointers
I:= 0;
repeat C:= ChIn(3); \read file into memory
Str(I):= C;
I:= I+1;
until C = $1A; \EOF
FClose(Handle); \release handle
 
Hello:= "Hello New York!"; \replacement text
Bye:= "Goodbye London!";
Pointer:= StrFind(Bye, Str);
if Pointer \#0\ then \overwrite (both strings are same length)
for I:= 0 to 15-1 do Pointer(I):= Hello(I);
 
Handle:= FOpen(FileName, 1); \get handle for output file
FSet(Handle, ^O); \set device 3 output to file handle
OpenO(3);
I:= 0;
repeat C:= Str(I); \write file from memory
I:= I+1;
ChOut(3, C);
until C = $1A; \EOF
Close(3); \flush output buffer
FClose(Handle); \release handle
];
 
int File, I;
[File:= ["Alpha.txt", "Beta.txt", "Gamma.txt", "Delta.txt"];
for I:= 0 to 4-1 do ReplaceText(File(I));
]</syntaxhighlight>
 
=={{header|zkl}}==
<syntaxhighlight lang="zkl">fcn sed(data,src,dst){
srcSz:=src.len(); dstSz:=dst.len(); md5:=Utils.MD5.calc(data);
n:=0; while(Void!=(n:=data.find(src,n)))
{ data.del(n,srcSz); data.insert(n,dst); n+= dstSz; }
return(md5!=Utils.MD5.calc(data)); // changed?
}
fcn sedFile(fname,src,dst){
f:=File(fname,"r"); data:=f.read(); f.close();
if(sed(data,"Goodbye London!", "Hello New York!"))
{ f:=File(fname,"w"); f.write(data); f.close(); }
}</syntaxhighlight>
This is a read file/blast it/write if changed. You could also do it line by line.
<syntaxhighlight lang="zkl">vm.arglist.apply2(sedFile);
$ zkl bbb foo.txt bar.txt</syntaxhighlight>
The apply2 method doesn't return anything, it is a side effects method.
You could also easily thread this (by using sedFile.launch or sedFile.strand depending on if you wanted a true thread or a co-op thread). I didn't because I didn't want to bother with checking for duplicate files or file locking.
vm.arglist, when passed to "main" (the constructor of the file being run) is a copy of argv that has been pruned.
 
{{omit from|HTML}}
9,476

edits