Globally replace text in several files: Difference between revisions
Globally replace text in several files (view source)
Revision as of 17:05, 7 December 2023
, 5 months ago→{{header|Wren}}: Changed to Wren S/H
(→{{header|Java}}: Add Java 11 shorter way.) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(22 intermediate revisions by 15 users not shown) | |||
Line 9:
=={{header|11l}}==
<
I fname.ends_with(‘.txt’)
V fcontents = File(fname).read()
File(fname, ‘w’).write(fcontents.replace(‘Goodbye London!’, ‘Hello, New York!’))
</syntaxhighlight>
=={{header|Ada}}==
<
procedure Global_Replace is
Line 76:
File_Replace(Ada.Command_Line.Argument(I), Pattern, Replacement);
end loop;
end Global_Replace;</
Ouput:
Line 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}}==
<
listFiles := "a.txt|b.txt|c.txt" ; Define a list of files in the current working directory
loop, Parse, listFiles, |
Line 108 ⟶ 114:
fileAppend, %contents%, %A_LoopField% ; Re-create the file with new contents
}
</syntaxhighlight>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f GLOBALLY_REPLACE_TEXT_IN_SEVERAL_FILES.AWK filename(s)
BEGIN {
Line 140 ⟶ 146:
exit(0)
}
</syntaxhighlight>
{{works with|gawk}}
<
BEGIN {
while(++i < ARGC)
print gensub("Goodbye London!","Hello New York!","g", readfile(ARGV[i])) > ARGV[i]
}</
=={{header|BASIC}}==
Line 154 ⟶ 160:
Pass the files on the command line (i.e. <code>global-replace *.txt</code>).
<
CONST repltext = "Hello New York!"
CONST matchlen = LEN(matchtext)
Line 191 ⟶ 197:
WEND
L0 += 1
WEND</
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
ReplaceWith$ = "Hello New York!"
Line 224 ⟶ 230:
OSCLI "REN """ + tmpfile$ + """ """ + infile$ + """"
NEXT
END</
=={{header|C}}==
<
#include <stdlib.h>
#include <stddef.h>
Line 301 ⟶ 307:
return 0;
}</
=={{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++}}==
<
#include <iterator>
#include <boost/regex.hpp>
Line 330 ⟶ 354:
}
return 0 ;
}</
Modern C++ version:
<
#include <fstream>
Line 351 ⟶ 375:
return 0;
}
</syntaxhighlight>
=={{header|Clojure}}==
<
(doseq [file more]
(spit file (.replace (slurp file) "Goodbye London!" "Hello New York!"))))</
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">
(defun hello-goodbye (files)
(labels ((replace-from-file (file)
Line 393 ⟶ 400:
(write-lines-to-file (replace-from-file file) file)))
(map nil #'replace-in-file files)))
</syntaxhighlight>
=={{header|D}}==
{{works with|D|2}}
<
void main() {
Line 404 ⟶ 411:
write(fn, replace(cast(string)read(fn), from, to));
}
}</
=={{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 ).
Line 430 ⟶ 471:
io:fwrite( "Error: Could not write ~p: ~p~n", [File, Error] ),
error.
</syntaxhighlight>
{{out}}
Line 456 ⟶ 497:
=={{header|F_Sharp|F#}}==
<
[<EntryPoint>]
Line 467 ⟶ 508:
if content <> newContent then
File.WriteAllText(name, newContent)
0</
=={{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}}==
Line 476 ⟶ 532:
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.<
CHARACTER*(*) FNAME !The name of the file, presumed to contain text.
CHARACTER*(*) THIS !The text sought in each record.
Line 540 ⟶ 596:
END DO !On to the next.
END</
=={{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}}==
<
import (
Line 593 ⟶ 735:
_, err = f.WriteAt(r, 0)
return
}</
=={{
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.
<
replace :: String -> String -> String -> String
Line 619 ⟶ 761:
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).
<
replace a b
where
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>
Line 641 ⟶ 794:
=={{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.
<
globalrepl("Goodbye London","Hello New York","a.txt","b.txt") # variable args for files
end
Line 655 ⟶ 808:
end
link strings # for replace</
{{libheader|Icon Programming Library}}
Line 664 ⟶ 817:
If <code>files</code> is a variable with the desired list of file names:
<
(1!:2~rplc&('Goodbye London!';'Hello New York!')@(1!:1))"0 files</
=={{header|Java}}==
Minimalistic version, assumes default encoding.
{{works with|Java|7}}
<
import java.nio.file.*;
Line 685 ⟶ 838:
}
}
}</
In Java 11 the body could be shortened to:
<
for (String fn : List.of("file1.txt","file2.txt")) {
Path path = Path.of(fn);
Line 694 ⟶ 847:
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".
<
do
jq -Rr 'gsub($from; $to)' --arg from 'Goodbye London!' --arg to 'Hello New York!' "$file" |
sponge "$file"
done</
The jq filter used above is `gsub/2`, which however is designed for regular expressions. Here is a string-oriented alternative:
<
($from | length) as $len
| def g:
index($from) as $ix
| if $ix then .[:$ix] + $to + (.[($ix+$len):] | g) else . end;
g;</
=={{header|Jsish}}==
'''For the demo, the code does not overwrite the samples, but creates a .new file.'''
<
if (console.args.length == 0) {
console.args.push('-');
Line 736 ⟶ 889:
}
} catch(err) { puts(err, 'processing', fn); }
}</
To meet the task specification, change
<
to
<
removing the else clause. The code will then overwrite originals.
Line 761 ⟶ 914:
=={{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).
<
for filename in filenames
txt = read(filename, String)
Line 767 ⟶ 920:
write(f, replace(txt, "Goodbye London!" => "Hello New York!"))
end
end</
=={{header|Kotlin}}==
<
import java.io.File
Line 784 ⟶ 937:
println(f.readText())
}
}</
{{out}}
Line 798 ⟶ 951:
=={{header|Lasso}}==
<
local(files = array('f1.txt', 'f2.txt'))
Line 811 ⟶ 964:
#file -> writebytes(#content)
}
}</
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
nomainwin
Line 851 ⟶ 1,004:
end if
end function
</syntaxhighlight>
=={{header|Lua}}==
<
for _, fn in pairs( filenames ) do
Line 865 ⟶ 1,018:
fp:write( str )
fp:close()
end</
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
Do[
filename = listOfFiles[[i]];
Line 875 ⟶ 1,027:
filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];
Export[filename, filetext, "Text"]
, {i, 1, Length[listOfFiles]}]</
File b.txt before the code is run:
<pre>second file for the Globally replace text in several files problem.
Line 889 ⟶ 1,041:
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}}==
<
for fn in ["a.txt", "b.txt", "c.txt"]:
fn.writeFile fn.readFile.replace(fr, to)</
=={{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}}==
<
i_cfile_list AS CHAR,
i_cfrom AS CHAR,
Line 921 ⟶ 1,104:
"Goodbye London!",
"Hello New York!"
).</
=={{header|Pascal}}==
{{works with|Free_Pascal}}
<
uses
Line 949 ⟶ 1,132:
AllText.Destroy;
end;
end.</
=={{header|Perl}}==
<
=={{header|Phix}}==
Line 965 ⟶ 1,141:
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}}==
<
(call 'mv File (tmp File))
(out File
(in (tmp File)
(while (echo "Goodbye London!")
(prin "Hello New York!") ) ) ) )</
=={{header|PowerBASIC}}==
{{trans|BASIC}}
<
$repltext = "Hello New York!"
Line 1,014 ⟶ 1,193:
INCR L0
WEND
END FUNCTION</
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
$listfiles = @('file1.txt','file2.txt')
$old = 'Goodbye London!'
Line 1,024 ⟶ 1,203:
(Get-Content $file).Replace($old,$new) | Set-Content $file
}
</syntaxhighlight>
=={{header|PureBasic}}==
<
Protected Line$, Out$, OutFile$, i
ForEach File$()
Line 1,058 ⟶ 1,237:
EndIf
Next
EndProcedure</
Implementation
<pre>NewList Xyz$()
Line 1,070 ⟶ 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.).
<
for line in fileinput.input(inplace=True):
print(line.replace('Goodbye London!', 'Hello New York!'), end='')
</syntaxhighlight>
=={{header|Racket}}==
Code wrapped in a convenient script:
<
#!/usr/bin/env racket
#lang racket
Line 1,102 ⟶ 1,281:
(begin (display-to-file text2 file #:exists 'replace)
(printf " modified copy saved in place\n")))))
</syntaxhighlight>
Sample run:
<pre>
Line 1,120 ⟶ 1,299:
</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}}==
<
>> str: read f
>> replace/all str "Goodbye London!" "Hello New York!"
>> write f str</
=={{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.
<
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*/
do f=1 for
say '──────── file is being read: ' fn " ("f 'out of'
call linein fn,1,0 /*position the file for input. */
changes=
do rec=0 while lines(fn)\==0 /*read a file (if it exists). */
@.rec= linein(fn)
if pos(old, @.rec)==0 then iterate /*Anything to change? No, then skip. */
changes= changes + 1
@.rec= changestr(old, @.rec, new)
end /*rec*/
Line 1,156 ⟶ 1,343:
say '──────── file was changed: ' fn " with" changes 'lines changed.'
end /*f*/ /*stick a fork in it, we're all done. */</
Some older REXXes don't have a '''changestr''' BIF, so one is included here ──► [[CHANGESTR.REX]].
<br><br>
<pre>
──────── file is being read: one.txt (1 out of 2 files).
Line 1,175 ⟶ 1,362:
===Version 2===
considering file ids that contain blanks
<
* Copy all files *.txt to *.rpl
* replacing all occurrences of old by new
Line 1,266 ⟶ 1,453:
ol=ol||s
End
Return ol</
Sample output:
<pre>
Line 1,290 ⟶ 1,477:
=={{header|Ring}}==
<
filenames = ["ReadMe.txt", "ReadMe2.txt"]
Line 1,311 ⟶ 1,498:
fseek(fp,0,C_FILESTART)
return nFileSize
</syntaxhighlight>
=={{header|Ruby}}==
Line 1,320 ⟶ 1,507:
=={{header|Run BASIC}}==
<
file$(2) ="data2.txt"
file$(3) ="data3.txt"
Line 1,352 ⟶ 1,539:
i = i + 1
WEND
END FUNCTION</
=={{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}}==
<
object GloballyReplaceText extends App {
Line 1,367 ⟶ 1,607:
}
}</
=={{header|Sed}}==
{{works with|GNU Sed}}
<
=={{header|Seed7}}==
<
include "getf.s7i";
Line 1,386 ⟶ 1,627:
putf(fileName, content);
end for;
end func;</
=={{header|Sidef}}==
<
a.txt
b.txt
Line 1,399 ⟶ 1,640:
line.gsub("Goodbye London!", "Hello New York!")
}
}</
=={{header|Tcl}}==
{{tcllib|fileutil}}
<
package require fileutil
Line 1,417 ⟶ 1,658:
foreach filename $fileList {
fileutil::updateInPlace $filename $replacementCmd
}</
=={{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}}==
<
$$ MODE TUSCRIPT
files="a.txt'b.txt'c.txt"
Line 1,442 ⟶ 1,700:
ENDLOOP
ERROR/STOP DELETE ("scratch")
</syntaxhighlight>
=={{header|TXR}}==
Line 1,448 ⟶ 1,706:
===Extraction Language===
<
@(repeat)
@file
Line 1,458 ⟶ 1,716:
@(end)
@(do @(rename-path `@file.tmp` file))
@(end)</
Run:
<pre>$ cat foo.txt
Line 1,484 ⟶ 1,742:
===TXR Lisp===
<
(let* ((infile (open-file fname))
(outfile (open-file `@fname.tmp` "w"))
Line 1,490 ⟶ 1,748:
(edited (regsub #/Goodbye, London/ "Hello, New York" content)))
(put-string edited outfile)
(rename-path `@fname.tmp` fname)))</
=={{header|UNIX Shell}}==
{{works with|bash}}
<
local search=$1 replace=$2
local file lines line
Line 1,506 ⟶ 1,764:
done
}
replace "Goodbye London!" "Hello New York!" a.txt b.txt c.txt</
{{works with|ksh93}}
<
typeset search=$1 replace=$2
typeset file lines line
Line 1,521 ⟶ 1,779:
done
}
replace "Goodbye London!" "Hello New York!" a.txt b.txt c.txt</
=={{header|VBScript}}==
{{works with|Windows Script Host|*}}
<syntaxhighlight lang="vbscript">
Const ForReading = 1
Const ForWriting = 2
Line 1,541 ⟶ 1,798:
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.
<
#20 = Reg_Free // text register for filename
Line 1,557 ⟶ 1,814:
Reg_Empty(#20) // Cleanup
Buf_Quit(OK)</
=={{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}}==
<
string 0; \use zero-terminated strings
Line 1,618 ⟶ 1,900:
[File:= ["Alpha.txt", "Beta.txt", "Gamma.txt", "Delta.txt"];
for I:= 0 to 4-1 do ReplaceText(File(I));
]</
=={{header|zkl}}==
<
srcSz:=src.len(); dstSz:=dst.len(); md5:=Utils.MD5.calc(data);
n:=0; while(Void!=(n:=data.find(src,n)))
Line 1,631 ⟶ 1,913:
if(sed(data,"Goodbye London!", "Hello New York!"))
{ f:=File(fname,"w"); f.write(data); f.close(); }
}</
This is a read file/blast it/write if changed. You could also do it line by line.
<
$ zkl bbb foo.txt bar.txt</
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.
|