Globally replace text in several files: Difference between revisions

=={{header|11l}}==

I fname.ends_with(‘.txt’)

V fcontents = File(fname).read()

File(fname, ‘w’).write(fcontents.replace(‘Goodbye London!’, ‘Hello, New York!’))

=={{header|Ada}}==

procedure Global_Replace is

File_Replace(Ada.Command_Line.Argument(I), Pattern, Replacement);

end loop;

Ouput:

=={{header|AutoHotkey}}==

listFiles := "a.txt|b.txt|c.txt" ; Define a list of files in the current working directory

loop, Parse, listFiles, |

fileAppend, %contents%, %A_LoopField% ; Re-create the file with new contents

}

=={{header|AWK}}==

# syntax: GAWK -f GLOBALLY_REPLACE_TEXT_IN_SEVERAL_FILES.AWK filename(s)

BEGIN {

exit(0)

}

{{works with|gawk}}

BEGIN {

while(++i < ARGC)

print gensub("Goodbye London!","Hello New York!","g", readfile(ARGV[i])) > ARGV[i]

=={{header|BASIC}}==

Pass the files on the command line (i.e. <code>global-replace *.txt</code>).

CONST repltext = "Hello New York!"

CONST matchlen = LEN(matchtext)

WEND

L0 += 1

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

ReplaceWith$ = "Hello New York!"

OSCLI "REN """ + tmpfile$ + """ """ + infile$ + """"

NEXT

=={{header|C}}==

#include <stdlib.h>

#include <stddef.h>

return 0;

=={{header|C sharp}}==

using System.Collections.Generic;

using System.IO;

}

}

=={{header|C++}}==

#include <iterator>

#include <boost/regex.hpp>

}

return 0 ;

Modern C++ version:

#include <fstream>

return 0;

}

=={{header|Clojure}}==

(doseq [file more]

=={{header|Common Lisp}}==

(defun hello-goodbye (files)

(labels ((replace-from-file (file)

(write-lines-to-file (replace-from-file file) file)))

(map nil #'replace-in-file files)))

=={{header|D}}==

{{works with|D|2}}

void main() {

write(fn, replace(cast(string)read(fn), from, to));

}

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{libheader| System.IoUtils}}

program Globally_replace_text_in_several_files;

begin

StringReplaceByFile('Goodbye London!', 'Hello New York!', ['a.txt', 'b.txt', 'c.txt']);

=={{header|Erlang}}==

-module( globally_replace_text ).

io:fwrite( "Error: Could not write ~p: ~p~n", [File, Error] ),

error.

{{out}}

=={{header|F_Sharp|F#}}==

[<EntryPoint>]

if content <> newContent then

File.WriteAllText(name, newContent)

=={{header|Factor}}==

{{works with|Factor|0.99 2019-10-06}}

splitting ;

qw{ a.txt b.txt c.txt }

=={{header|Fortran}}==

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.

CHARACTER*(*) FNAME !The name of the file, presumed to contain text.

CHARACTER*(*) THIS !The text sought in each record.

END DO !On to the next.

=={{header|FreeBASIC}}==

{{trans|BASIC}}

Const repltext = "Hello New York!"

Const matchlen = Len(matchtext)

Wend

L0 += 1

=={{header|Go}}==

import (

_, err = f.WriteAt(r, 0)

return

=={{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.

replace :: String -> String -> String -> String

f <- mapM readFile files

return $ map (replace a1 a2) f

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 = go

where

go xxs@(x : xs)

| a `isPrefixOf` xxs = b <> go (drop w xxs)

and with different library imports, we could also write things like:

import Data.List.Split (splitOn)

replace :: String -> String -> String -> String

=={{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

end

{{libheader|Icon Programming Library}}

If <code>files</code> is a variable with the desired list of file names:

=={{header|Java}}==

Minimalistic version, assumes default encoding.

{{works with|Java|7}}

import java.nio.file.*;

}

}

In Java 11 the body could be shortened to:

for (String fn : List.of("file1.txt","file2.txt")) {

Path path = Path.of(fn);

Files.readString(path).replace("Goodbye London!", "Hello New York!"));

}

=={{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"

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;

=={{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('-');

}

} catch(err) { puts(err, 'processing', fn); }

To meet the task specification, change

to

removing the else clause. The code will then overwrite originals.

=={{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)

write(f, replace(txt, "Goodbye London!" => "Hello New York!"))

end

=={{header|Kotlin}}==

import java.io.File

println(f.readText())

}

{{out}}

=={{header|Lasso}}==

local(files = array('f1.txt', 'f2.txt'))

#file -> writebytes(#content)

}

=={{header|Liberty BASIC}}==

nomainwin

end if

end function

=={{header|Lua}}==

for _, fn in pairs( filenames ) do

fp:write( str )

fp:close()

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Do[

filename = listOfFiles[[i]];

filetext = StringReplace[filetext, "Goodbye London!" -> "Hello New York!"];

Export[filename, filetext, "Text"]

File b.txt before the code is run:

<pre>second file for the Globally replace text in several files problem.

=={{header|newLISP}}==

{{works with|newLisp|10.7.5}}

(define (replace-in-file filename this bythat)

(set 'content (read-file filename))

(exit)

=={{header|Nim}}==

let fr = "Goodbye London!"

for fn in ["a.txt", "b.txt", "c.txt"]:

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

files := ["text1.txt", "text2.txt"];

};

}

=={{header|OpenEdge/Progress}}==

i_cfile_list AS CHAR,

i_cfrom AS CHAR,

"Goodbye London!",

"Hello New York!"

=={{header|Pascal}}==

{{works with|Free_Pascal}}

uses

AllText.Destroy;

end;

=={{header|Perl}}==

=={{header|Phix}}==

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.

<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: #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>

=={{header|PicoLisp}}==

(call 'mv File (tmp File))

(out File

(in (tmp File)

(while (echo "Goodbye London!")

=={{header|PowerBASIC}}==

{{trans|BASIC}}

$repltext = "Hello New York!"

INCR L0

WEND

=={{header|PowerShell}}==

$listfiles = @('file1.txt','file2.txt')

$old = 'Goodbye London!'

(Get-Content $file).Replace($old,$new) | Set-Content $file

}

=={{header|PureBasic}}==

Protected Line$, Out$, OutFile$, i

ForEach File$()

EndIf

Next

Implementation

<pre>NewList Xyz$()

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='')

=={{header|Racket}}==

Code wrapped in a convenient script:

#!/usr/bin/env racket

#lang racket

(begin (display-to-file text2 file #:exists 'replace)

(printf " modified copy saved in place\n")))))

Sample run:

<pre>

Current Raku implementations do not yet support the -i flag for editing files in place, so we roll our own (rather unsafe) version:

=={{header|Red}}==

>> str: read f

>> replace/all str "Goodbye London!" "Hello New York!"

=={{header|REXX}}==

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. */

say '──────── file was changed: ' fn " with" changes 'lines changed.'

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

<br><br>

===Version 2===

considering file ids that contain blanks

* Copy all files *.txt to *.rpl

* replacing all occurrences of old by new

ol=ol||s

End

Sample output:

<pre>

=={{header|Ring}}==

filenames = ["ReadMe.txt", "ReadMe2.txt"]

fseek(fp,0,C_FILESTART)

return nFileSize

=={{header|Ruby}}==

=={{header|Run BASIC}}==

file$(2) ="data2.txt"

file$(3) ="data3.txt"

i = i + 1

WEND

=={{header|Rust}}==

//! Author: Rahul Sharma

//! Github: <https://github.com/creativcoder>

}

}

{{out}}

<pre>

=={{header|Scala}}==

object GloballyReplaceText extends App {

}

=={{header|Sed}}==

{{works with|GNU Sed}}

=={{header|Seed7}}==

include "getf.s7i";

putf(fileName, content);

end for;

=={{header|Sidef}}==

a.txt

b.txt

line.gsub("Goodbye London!", "Hello New York!")

}

=={{header|Tcl}}==

{{tcllib|fileutil}}

package require fileutil

foreach filename $fileList {

fileutil::updateInPlace $filename $replacementCmd

=={{header|Transd}}==

MainModule: {

(write fs (to-bytes s) (size s)))))

)

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

files="a.txt'b.txt'c.txt"

ENDLOOP

ERROR/STOP DELETE ("scratch")

=={{header|TXR}}==

===Extraction Language===

@(repeat)

@file

@(end)

@(do @(rename-path `@file.tmp` file))

Run:

<pre>$ cat foo.txt

===TXR Lisp===

(let* ((infile (open-file fname))

(outfile (open-file `@fname.tmp` "w"))

(edited (regsub #/Goodbye, London/ "Hello, New York" content)))

(put-string edited outfile)

=={{header|UNIX Shell}}==

{{works with|bash}}

local search=$1 replace=$2

local file lines line

done

}

{{works with|ksh93}}

typeset search=$1 replace=$2

typeset file lines line

done

}

=={{header|VBScript}}==

{{works with|Windows Script Host|*}}

Const ForReading = 1

Const ForWriting = 2

Next

End With

=={{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

Reg_Empty(#20) // Cleanup

=={{header|Wren}}==

var files = ["file1.txt", "file2.txt"]

}

System.print("%(file) now contains: %(File.read(file))")

{{out}}

=={{header|XPL0}}==

string 0; \use zero-terminated strings

[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)))

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.

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.