Globally replace text in several files: Difference between revisions

For this task we want to replace the text   "'''Goodbye London!'''"   with   "'''Hello New York!'''"   for a list of files.

<br><br>

 

=={{header|Ada}}==

 

 

procedure Global_Replace is

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

end loop;

 

Ouput:

"Hello New York!"

"Byebye London!" "Byebye London!" "Byebye London!" </pre>

 

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

#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|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|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|Go}}==

 

import (

_, 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

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

'''Example:'''

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

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

 

}

}

 

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

open(filename, "w") do f

end

 

 

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

Bye bye London! Bye bye London!

</pre>

 

=={{header|Nim}}==

 

 

for fn in ["a.txt", "b.txt", "c.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|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>

</pre>

 

 

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

parse arg fileList /*obtain required list of files from CL*/

 

call linein fn,1,0 /*position the file for input. */

do rec=0 while lines(fn)\==0 /*read a file (if it exists). */

if pos(old, @.rec)==0 then iterate /*Anything to change? No, then skip. */

end /*rec*/

 

 

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>

<pre>

──────── file is being read: one.txt (1 out of 2 files).

===Version 2===

considering file ids that contain blanks

* Copy all files *.txt to *.rpl

* replacing all occurrences of old by new

* 16.01.2013 Walter Pachl

* ...if file names contain blanks

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|Sed}}==

{{works with|GNU Sed}}

 

=={{header|Seed7}}==

include "getf.s7i";

putf(fileName, content);

end for;

 

=={{header|Sidef}}==

a.txt

b.txt

c.txt

say file.edit { |line|

 

=={{header|Tcl}}==

{{tcllib|fileutil}}

package require fileutil

 

foreach filename $fileList {

fileutil::updateInPlace $filename $replacementCmd

 

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