Globally replace text in several files: Difference between revisions

{{task}}

 

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

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

 

 

 

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.