File input/output

File input/output
You are encouraged to solve this task according to the task description, using any language you may know.

File input/output is part of Short Circuit's Console Program Basics selection.

In this task, the job is to create a file called "output.txt", and place in it the contents of the file "input.txt".

Ada

If the file line size exceeds the size of the input string the output file will contain extra new-line characters. <lang ada>with Ada.Text_IO; use Ada.Text_IO; procedure File_IO is

  Input, Output : File_Type;
  Line : String (1 .. 10_000);
  Last : Natural;

begin

  Create (Output, Out_File, "output.txt");
  Open (Input, In_File, "input.txt");
  while not End_Of_File (Input) loop
     Get_Line (Input, Line, Last);
     Put_Line (Output, Line (1 .. Last));
  end loop;
  Close (Input);
  Close (Output);

end File_IO;</lang> Note that it is possible to use a version of Get_Line that returns the read line as one string of unspecified length: <lang ada>while not End_Of_File (Input) loop

  Put_Line (Output, Get_Line (Input));

end loop;</lang> But it is not recommended, because it would make program vulnerable to storage error problems.

The following example reads and writes each file one character at a time. There is no new-line issue. <lang ada>with Ada.Sequential_Io;

procedure File_Io is

  package Char_Io is new Ada.Sequential_Io(Character);
  use Char_Io;
  Infile, Outfile : File_Type;
  Value : Character;

begin

  Create(File => Outfile, Mode => Out_File, Name => "output.txt");
  Open(File => Infile, Mode => In_File, Name => "input.txt");
  while not End_Of_File(Infile) loop
     Read(File => Infile,  Item => Value);
     Write(File => Outfile, Item => Value);
  end loop;
  Close(Infile);
  Close(Outfile);

end File_IO;</lang> The following solution uses stream I/O. Any file of Ada.Text_IO can be used to obtain a corresponding stream. Reading and writing streams is more efficient than reading text files directly, because it skips formatting. Note also how End_Error exception is used to avoid End_Of_File. End_Of_File is depreciated as it requires file look-ahead, and thus is much less efficient. <lang ada>with Ada.Text_IO; use Ada.Text_IO; with Ada.Text_IO.Text_Streams; use Ada.Text_IO.Text_Streams;

procedure File_Io is

  Infile, Outfile : File_Type;

begin

  Create (File => Outfile, Mode => Out_File, Name => "output.txt");
  Open (File => Infile, Mode => In_File, Name => "input.txt");
  loop
     Character'Write (Stream (Outfile), Character'Input (Stream (Infile)));
  end loop;

exception

  when End_Error =>
     Close (Infile);
     Close (Outfile);

end File_IO;</lang>

ALGOL 68

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d

<lang algol68>PROC copy file v1 = (STRING in name, out name)VOID: (

 # note: algol68toc-1.18 - can compile, but not run v1 #
 INT errno;
 FILE in file, out file;
 errno := open(in  file, in  name, stand in  channel);
 errno := open(out file, out name, stand out channel);

 BOOL in ended := FALSE;
 PROC call back ended = (REF FILE f) BOOL: in ended := TRUE;
 on logical file end(in file, call back ended);

 STRING line;
 WHILE
   get(in  file, (line, new line));

1. WHILE # NOT in ended DO # break to avoid excess new line #

   put(out file, (line, new line))
 OD;

ended:

 close(in  file);
 close(out file)

);

PROC copy file v2 = (STRING in name, out name)VOID: (

 INT errno;
 FILE in file, out file;
 errno := open(in file, in name, stand in channel);
 errno := open(out file, out name, stand out channel);

 PROC call back ended = (REF FILE f) BOOL: GO TO done;
 on logical file end(in file, call back ended);

 STRING line;
 DO
   get(in  file, line);
   put(out file, line);
   get(in  file, new line);
   put(out file, new line)
 OD;

done:

 close(in file);
 close(out file)

);

test:(

 copy file v2("input.txt","output.txt")

)</lang>

AppleScript

<lang applescript>on copyFile from src into dst

      set filedata to read file src
      set outfile to open for access dst with write permission
      write filedata to outfile
      close access outfile

end copyFile

copyFile from ":input.txt" into ":output.txt"</lang>

AutoHotkey

Method 1: the input file can be processed line by line. <lang AutoHotkey>Loop, Read, input.txt, output.txt

FileAppend, %A_LoopReadLine%`n</lang>

Method 2: the input file can be read at once if it is less than 1 GB. <lang autohotkey>FileRead, var, input.txt FileAppend, %var%, output.txt</lang> Method 3: the file can be copied without IO. <lang autohotkey>FileCopy, input.txt, output.txt</lang>

Binary IO is possible with this library from Laszlo.

AWK

(This does not handle properly binary files)

<lang awk>BEGIN {

 while ( (getline <"input.txt") > 0 ) {
   print >"output.txt"
 }

}</lang>

BASIC

Works with: QuickBasic version 4.5

<lang qbasic> OPEN "INPUT.TXT" FOR INPUT AS #1

OPEN "OUTPUT.TXT" FOR OUTPUT AS #2
DO UNTIL EOF(1)
  LINE INPUT #1, Data$
  PRINT #2, Data$
LOOP
CLOSE #1
CLOSE #2
SYSTEM</lang>

Batch File

<lang dos>copy input.txt output.txt</lang> or <lang dos>type input.txt > output.txt</lang> or <lang dos>for /f "" %L in ('more^<input.txt') do echo %L>>output.txt</lang>

There may be other techniques too.

BBC BASIC

BBC BASIC for Windows has a file copy command: <lang bbcbasic> *COPY input.txt output.txt</lang> Alternatively the copy can be done explicitly: <lang bbcbasic> infile% = OPENIN("input.txt")

     outfile% = OPENOUT("output.txt")
     WHILE NOT EOF#infile%
       BPUT #outfile%, BGET#infile%
     ENDWHILE
     CLOSE #infile%
     CLOSE #outfile%</lang>

Befunge

Works with: CCBI version 2.1

<lang befunge>0110"txt.tupni"#@i10"txt.tuptuo"#@o@</lang>

This linear program tries to open "input.txt" as text file (or aborts). It then writes the content in text mode (i.e. minus trailing spaces) to "output.txt" (or aborts).

Bracmat

<lang>put$(get$"input.txt","output.txt",NEW)</lang>

C

<lang c>#include <stdio.h>

int main(int argc, char **argv) {

 FILE *in, *out;
 int c;

 in = fopen("input.txt", "r");
 if (!in) {
   fprintf(stderr, "Error opening input.txt for reading.\n");
   return 1;
 }

 out = fopen("output.txt", "w");
 if (!out) {
   fprintf(stderr, "Error opening output.txt for writing.\n");
   fclose(in);
   return 1;
 }

 while ((c = fgetc(in)) != EOF) {
   fputc(c, out);
 }

 fclose(out);
 fclose(in);
 return 0;

}</lang>

A couple of remarks on the preceding example:

It uses fgetc to read one character at a time. Each character is visited, even though there's nothing to do with it. Copying bigger blocks of data is much more efficient.

The following example addresses those issues. To avoid buffered IO, it uses open(), read(), write() and close(), which are part of POSIX.

Works with: POSIX

<lang c>#include <unistd.h>

1. include <fcntl.h>
2. include <sys/types.h>
3. include <sys/stat.h>

/* we just return a yes/no status; caller can check errno */ int copy_file(char *in, char *out) { int ret = 0; int fin, fout; ssize_t len; char *buf[4096]; /* buffer size, some multiple of block size preferred */ struct stat st;

if ((fin = open(in, O_RDONLY)) == -1) return 0; if (fstat(fin, &st)) goto bail;

/* open output with same permission */ fout = open(out, O_WRONLY|O_CREAT|O_TRUNC, st.st_mode & 0777); if (fout == -1) goto bail;

while ((len = read(fin, buf, 4096)) > 0) write(fout, buf, len);

ret = len ? 0 : 1; /* last read should be 0 */

bail: if (fin != -1) close(fin); if (fout != -1) close(fout); return ret; }

int main() { copy_file("infile", "outfile"); return 0; }</lang>

If it's certain that mapping the whole input file into memory poses no problem (there can be all kinds of problems), this may be the most efficient:<lang c>int copy_file(char *in, char *out) { int ret = 0; int fin, fout; char *bi; struct stat st;

if ((fin = open(in, O_RDONLY)) == -1) return 0; if (fstat(fin, &st)) goto bail;

fout = open(out, O_WRONLY|O_CREAT|O_TRUNC, st.st_mode & 0777); if (fout == -1) goto bail;

bi = mmap(0, st.st_size, PROT_READ, MAP_PRIVATE, fin, 0);

ret = (bi == (void*)-1) ? 0 : (write(fout, bi, st.st_size) == st.st_size);

bail: if (fin != -1) close(fin); if (fout != -1) close(fout); if (bi != (void*)-1) munmap(bi, st.st_size); return ret; }</lang>

C#

The long way:

<lang csharp>using System.IO;

using (var reader = new StreamReader("input.txt")) using (var writer = new StreamWriter("output.txt")) {

   var text = reader.ReadToEnd();
   writer.Write(text);

}</lang>

The short way:

<lang csharp>using System.IO;

var text = File.ReadAllText("input.txt"); File.WriteAllText("output.txt", text);</lang>

C++

Works with: g++ version 3.4.2

<lang cpp>#include <iostream>

1. include <fstream>
2. include <string>

using namespace std;

int main() {

   string line;
   ifstream input ( "input.txt" );
   ofstream output ("output.txt");
   
   if (output.is_open()) {
       if (input.is_open()){
           while (getline (input,line)) {
               output << line << endl;
           }
           input.close(); // Not necessary - will be closed when variable goes out of scope.
       }
       else {
           cout << "input.txt cannot be opened!\n";
       }
       output.close(); // Not necessary - will be closed when variable goes out of scope.
   }
   else {
       cout << "output.txt cannot be written to!\n";
   }
   return 0;

}</lang>

Simpler version:

<lang cpp>#include <iostream>

1. include <fstream>
2. include <cstdlib>

int main() {

 std::ifstream input("input.txt");
 if (!input.is_open())
 {
   std::cerr << "could not open input.txt for reading.\n";
   return EXIT_FAILURE;
 }
 
 std::ofstream output("output.txt");
 if (!output.is_open())
 {
   std::cerr << "could not open output.txt for writing.\n";
   return EXIT_FAILURE;
 }
 
 output << input.rdbuf();
 if (!output)
 {
   std::cerr << "error copying the data.\n";
   return EXIT_FAILURE;
 }
 
 return EXIT_SUCCESS;

}</lang>

Using istream- and ostream- iterators:

<lang cpp># include <algorithm>

1. include <fstream>

int main() {

 std::ifstream ifile("input.txt");
 std::ofstream ofile("output.txt");
 std::copy(std::istreambuf_iterator<char>(ifile),
           std::istreambuf_iterator<char>(),
           std::ostreambuf_iterator<char>(ofile));

}</lang>

Even simpler way:

<lang cpp>#include <fstream>

int main() {

 std::ifstream input("input.txt");
 std::ofstream output("output.txt");
 output << input.rdbuf();

}</lang>

Clean

Define a function that copies the content from one file to another.

<lang clean>import StdEnv

copyFile fromPath toPath world

   # (ok, fromFile, world) = fopen fromPath FReadData world
   | not ok = abort ("Cannot open " +++ fromPath +++ " for reading")
   # (ok, toFile, world) = fopen toPath FWriteData world
   | not ok = abort ("Cannot open " +++ toPath +++ " for writing")
   # (fromFile, toFile) = copyData 1024 fromFile toFile
   # (ok, world) = fclose fromFile world
   | not ok = abort ("Cannot close " +++ fromPath +++ " after reading")
   # (ok, world) = fclose toFile world
   | not ok = abort ("Cannot close " +++ toPath +++ " after writing")
   = world

where

   copyData bufferSize fromFile toFile
       # (buffer, fromFile) = freads fromFile bufferSize
       # toFile = fwrites buffer toFile
       | size buffer < bufferSize = (fromFile, toFile) // we're done
       = copyData bufferSize fromFile toFile // continue recursively</lang>

Apply this function to the world to copy a file.

<lang clean>Start world = copyFile "input.txt" "output.txt" world</lang>

Clojure

<lang lisp> (use 'clojure.java.io)

(copy (file "input.txt") (file "output.txt")) </lang>

<lang lisp>

simple file writing

(spit "filename.txt" "your content here")

simple file reading

(slurp "filename.txt") </lang>

ColdFusion

<lang cfm><cfif fileExists(expandPath("input.txt"))>

 <cffile action="read" file="#expandPath('input.txt')#" variable="inputContents">
 <cffile action="write" file="#expandPath('output.txt')#" output="#inputContents#">

</cfif></lang>

Common Lisp

By lines:

<lang lisp>(with-open-file (in #p"input.txt" :direction :input)

 (with-open-file (out #p"output.txt" :direction :output)
   (loop for line = (read-line in nil 'foo)
         until (eq line 'foo)
         do (write-line line out))))</lang>

By arbitrary blocks and for possibly-binary files:

<lang lisp>(defconstant +buffer-size+ (expt 2 16))

(with-open-file (in #p"input.txt" :direction :input

                               :element-type '(unsigned-byte 8))
 (with-open-file (out #p"output.txt" 
                  :direction :output
                  :element-type (stream-element-type in))
   (loop with buffer = (make-array +buffer-size+
                                   :element-type (stream-element-type in))
         for size = (read-sequence buffer in)
         while (plusp size)
         do (write-sequence buffer out :end size))))</lang>

If you're on an odd platform which actually stores text/binary/... type information for files and your CL implementation will use this information, then in should be opened with :element-type :default.

D

Works with: D version 2

<lang d>import std.file: copy;

void main() {

   copy("input.txt", "output.txt");

}</lang>

Library: Tango

Works with: D version 1

Copy the content from one file to another (exceptions are handled by Tango): <lang d>import tango.io.device.File;

void main() {

   auto from = new File("input.txt");
   auto to = new File("output.txt", File.WriteCreate);
   to.copy(from).close;
   from.close;

}</lang> Or a shorter example without explicitly closing the output file: <lang d>import tango.io.device.File;

void main() {

   auto to = new File("output.txt", File.WriteCreate);
   to.copy(new File("input.txt")).close;

}</lang>

Delphi

Delphi supports both typed and untyped as well as a textfile type for files. Delphi provides a default 128 byte buffer for text files. This may be enlarged via a call to SetTextBuff(Var F: Text; Var Buf [Size : integer]) procedure. All other files have no buffer at all and it is the programmers option to do buffering.

The following file I/O procedures have existed since Turbo Pascal V-3.

- Read(F,V1..Vn)
- ReadLn(F,V1..Vn)
- Write(F,V1[,V2..Vn])
- WriteLn(f,V1[,V2..Vn])
- BlockRead(F,Buff,BytesToRead[,BytesRead])
- BlockWrite(F,Buff,BytesToRead[,BytesWritten])

Files are opened using:

AssignFile(f,{fully qualified path and file name})

---

Assigns the file name to the file structure in preparation for opening.

Reset(f)

Opens and existing file. If it does not exist EIOError is raised.

---

Rewrite(f)

Creates a new file and opens it for I/O. If the files exists is is overwritten.

Delphi implemented Streams of which a variant is TFileStream and are very closely related to the Windows API for file handling.

- Text File I/O -

<lang delphi>var

 f : TextFile ;
 s : string ;

begin

 AssignFile(f,[fully qualified file name);
 Reset(f);
 writeln(f,s);
 Reset(f);
 ReadLn(F,S);  
 CloseFile(

end;</lang>

- Untyped File I/O -

This is perhaps one of the most powerful I/O functions built into Pascal. This will allow you to open and read a file of ANY type, regardless of structure, size or content. Note the usage of Reset(). This is using the optional size parameter that instructs the record size of file I/O. This could have been called with SizeOf(Buff) as the optional parameter but that would have limited flexibility. Calling it with a size of ONE byte allows you to adjust the buffer size on the fly, as conditions warrant. Also note the use of the BytesRead parameter. When included in the BlockRead() function it will return the number of bytes actually read. If this is not included, then if your directive to read n bytes is greater then the size of the file, the EOF will be encountered unexpectedly and EIOError will be raised.

<lang delphi>var

 f         : File ;
 buff      : array[1.1024] of byte ;
 BytesRead : Integer ;

begin

 AssignFile(f,fully qualified file name);  
 Reset(f,1);
 Blockread(f,Buff,SizeOf(Buff),BytesRead); 
 CloseFile(f);

end;</lang>

- Typed File I/O -

Typed file I/O is very useful when reading and writing structures. An Address List is quiet easy to write when using this type of I/O. The same file procedures are used with some subtle differences. Bite below in the blockread and blockwrite procedures that the bytes to read or write are 1. Also note that the reset procedure is not called with a buffer size. When performing Typed File I/O the size of the type definition is the buffer size. In the BlockRead() and BlockWrite() procedures I elected to read one record. Had I declared a very large buffer of type tAddressBook of say 500 records, I could have set bytes to read as SizeOf(Buffer) thereby reading a minimum of 500 records.

<lang delphi>type

 tAddressBook = Record
                 FName   : string[20];
                 LName   : string[30];
                 Address : string[30];
                 City    : string[30];
                 State   : string[2];
                 Zip5    : string[5];
                 Zip4    : string[4];
                 Phone   : string[14];
                 Deleted : boolean ;
               end;

var

 f     : file of tAddressBook ;
 v     : tAddressBook ;
 bytes : integer ;

begin

 AssignFile(f,fully qualified file name);  
 Reset(f);
 Blockread(f,V,1,Bytes);
 Edit(v);
 Seek(F,FilePos(f)-1);
 BlockWrite(f,v,1,bytes);
 CloseFile(f);

end;</lang>

E

Works with: E-on-Java

<lang e><file:output.txt>.setText(<file:input.txt>.getText())</lang>

(This version holds the entire contents in memory.)

Eiffel

<lang eiffel >class

   APPLICATION

create

   make

feature {NONE} -- Initialization

   make
           -- Run application.
       do
           create input_file.make_open_read ("input.txt")
           create output_file.make_open_write ("output.txt")

           from
               input_file.read_character
           until
               input_file.exhausted
           loop
               output_file.put (input_file.last_character)
               input_file.read_character
           end

           input_file.close
           output_file.close
       end

feature -- Access

   input_file: PLAIN_TEXT_FILE
   output_file: PLAIN_TEXT_FILE

end</lang>

Euphoria

Read the entire file and then write it

Works with: Euphoria version 4.0.0

<lang euphoria>include std/io.e write_lines("output.txt", read_lines("input.txt"))</lang>

Line-by-line reading and writing

Works with: Euphoria version any

<lang euphoria>integer in,out object line

in = open("input.txt","r") out = open("output.txt","w")

while 1 do

   line = gets(in)
   if atom(line) then -- EOF reached
       exit
   end if
   puts(out,line)

end while

close(out) close(in)</lang>

Erlang

This version uses the built-in function file:copy/2. <lang erlang>file:copy("input.txt","output.txt").</lang>

F#

<lang fsharp>open System.IO

let read = File.ReadAllText let write file text = File.WriteAllText(file, text)

"input.txt" |> read |> write "output.txt" </lang>

Factor

Holds entire file content in memory: <lang factor>"input.txt" binary file-contents "output.txt" binary set-file-contents</lang> A bit longer, but only holds a small amount of data in memory. If opening the file for writing fails, we want to clean up the file that's open for reading: <lang factor>[

   "input.txt" binary <file-reader> &dispose
   "output.txt" binary <file-writer> stream-copy

] with-destructors </lang> Possibly cheating: <lang factor>"input.txt" "output.txt" copy-file</lang>

Forth

Forth traditionally has not had any file handling capabilities, preferring instead to operate on a disk image block by block. Most modern Forth systems however run under an existing operating system and provide methods for disk access.

<lang forth>\ <to> <from> copy-file

copy-file ( a1 n1 a2 n2 -- )

   r/o open-file throw >r
   w/o create-file throw r>
   begin
       pad maxstring  2 pick  read-file throw
   ?dup while
       pad swap  3 pick  write-file throw
   repeat
   close-file throw
   close-file throw ;

\ Invoke it like this: s" output.txt" s" input.txt" copy-file</lang>

Note the use of "2 pick" to get the input file handle and "3 pick" to get the output file handle. Local or global variables could have been used, but in this implementation simple stack manipulation was chosen. Also, only maxstring bytes are copied at a time, and the global "pad" memory area is used to hold the data. For faster copies, allocating a larger buffer could be advantageous.

Also, abort" can be used instead of throw if desired.

Fortran

Works with: Fortran version 2003

Works with: gfortran version 4.3.2

It uses the access="stream" which is defined in Fortran 2003 standard and should allow to "copy" also binary data easily.

<lang fortran>program FileIO

 integer, parameter :: out = 123, in = 124
 integer :: err
 character(len=1) :: c

 open(out, file="output.txt", status="new", action="write", access="stream", iostat=err)
 if ( err == 0 ) then
    open(in, file="input.txt", status="old", action="read", access="stream", iostat=err)
    if ( err == 0 ) then
       err = 0
       do while ( err == 0 )
          read(unit=in, iostat=err) c
          if ( err == 0 ) write(out) c
       end do
       close(in)
    end if
    close(out)
 end if

end program FileIO</lang>

GAP

<lang gap>CopyFile := function(src, dst)

 local f, g, line;
 f := InputTextFile(src);
 g := OutputTextFile(dst, false);
 while true do
   line := ReadLine(f);
   if line = fail then
     break
   else
     WriteLine(g, Chomp(line));
   fi;
 od;
 CloseStream(f);
 CloseStream(g);

end;</lang>

GML

<lang GML>file_copy("input.txt","output.txt")</lang>

Go

<lang go>package main

import (

   "io"
   "log"
   "os"

)

func CopyFile(out, in string) (err error) {

   var inf, outf *os.File
   inf, err = os.Open(in)
   if err != nil {
       return
   }
   defer func() {
       cErr := inf.Close()
       if err == nil {
           err = cErr
       }
   }()
   outf, err = os.Create(out)
   if err != nil {
       return
   }
   _, err = io.Copy(outf, inf)
   cErr := outf.Close()
   if err == nil {
       err = cErr
   }
   return

}

func main() {

   if err := CopyFile("output.txt", "input.txt"); err != nil {
       log.Fatal(err)
   }

}</lang>

Groovy

Using File <lang groovy>new File('output.txt').write(new File('input.txt').text)</lang>

Using Ant <lang groovy>new AntBuilder().copy(file:'input.txt', toFile:'output.txt', overwrite:true)</lang>

Buffered <lang groovy>new File('output.txt').withWriter( w ->

 new File('input.txt').withReader( r -> w << r }

}</lang>

GUISS

<lang guiss>Start,My Documents,Rightclick:input.txt,Copy,Menu,Edit,Paste, Rightclick:Copy of input.txt,Rename,Type:output.txt[enter]</lang>

Haskell

Note: this doesn't keep the file in memory. Buffering is provided by lazy evaluation. <lang haskell>main = readFile "input.txt" >>= writeFile "output.txt"</lang>

HicEst

Copy via system call: <lang hicest>CHARACTER input='input.txt ', output='output.txt ', c, buffer*4096 SYSTEM(COPY=input//output, ERror=11) ! on error branch to label 11 (not shown)</lang> Read and write line by line <lang hicest>OPEN(FIle=input, OLD, ERror=21) ! on error branch to label 21 (not shown) OPEN(FIle=output)

   DO i = 1, 1E300 ! "infinite" loop, exited on end-of-file error
     READ( FIle=input,  ERror=22) buffer ! on error (end of file) branch to label 22
     WRITE(FIle=output, ERror=23) buffer ! on error branch to label 23 (not shown)
   ENDDO

22 WRITE(FIle=output, CLoSe=1)</lang> Read and write in 1 block <lang hicest>OPEN(FIle=input, SEQuential, UNFormatted, OLD, LENgth=len, ERror=31) ! on error branch to label 31 (not shown) OPEN(FIle=output, SEQuential, UNFormatted, ERror=32) ! on error branch to label 32 (not shown) ALLOCATE(c, len) READ(FIle=input, CLoSe=1) c WRITE(FIle=output, CLoSe=1) c END</lang>

Icon and Unicon

Icon and Unicon I/O by default is line driven. This can be changed with options in open and by the use of reads() and writes(). <lang Icon>procedure main() in  := open(f := "input.txt","r") | stop("Unable to open ",f) out := open(f := "output.txt","w") | stop("Unable to open ",f) while write(out,read(in)) end</lang>

IDL

<lang idl>; open two LUNs openw,unit1,'output.txt,/get openr,unit2,'input.txt',/get

how many bytes to read

fs = fstat(unit2)

make buffer

buff = bytarr(fs.size)

transfer content

readu,unit2,buff writeu,unit1,buff

that's all

close,/all</lang>

J

<lang j> 'output.txt' (1!:2~ 1!:1)&< 'input.txt'</lang>

Or using the system library files:

<lang j>require 'files' 'output.txt' (fwrite~ fread) 'input.txt'</lang>

Java

Works with: GCJ version 4.1.2

Simple version; Files may be closed automatically by OS, on some systems.

<lang java>import java.io.*;

public class FileIODemo {

 public static void main(String[] args) {
   try {
     FileInputStream in = new FileInputStream("input.txt");
     FileOutputStream out = new FileOutputStream("ouput.txt");
     int c;
     while ((c = in.read()) != -1) {
       out.write(c);
     }
   } catch (FileNotFoundException e) {
     e.printStackTrace();
   } catch (IOException e){
     e.printStackTrace();
   }
 }

}</lang>

This version closes both files after without OS intervention

<lang java>import java.io.*;

public class FileIODemo2 {

 public static void main(String args[]) {
   try {
     // Probably should wrap with a BufferedInputStream
     final InputStream in = new FileInputStream("input.txt");
     try {
       // Probably should wrap with a BufferedOutputStream
       final OutputStream out = new FileOutputStream("output.txt");
       try {
         int c;
         while ((c = in.read()) != -1) {
           out.write(c);
         }
       }
       finally {
         out.close();
       }
     }
     finally {
       in.close();
     }
   } catch (FileNotFoundException e) {
     e.printStackTrace();
   } catch (IOException e){
     e.printStackTrace();
   }
 }

}</lang>

Works with: Java version 1.4

Package nio

<lang java>import java.io.*; import java.nio.channels.*;

public class FileIODemo3 {

 public static void main(String args[]) {
   try {
     final FileChannel in = new FileInputStream("input.txt").getChannel();
     try {
       final FileChannel out = new FileOutputStream("output.txt").getChannel();
       try {
         out.transferFrom(in, 0, in.size());
       }
       finally {
         out.close();
       }
     }
     finally {
       in.close();
     }
   }
   catch (Exception e) {
     System.err.println("Exception while trying to copy: "+e);
     e.printStackTrace(); // stack trace of place where it happened
   }
 }

}</lang>

This version is more in line with the other languages' implementations: it assumes simple text files, and doesn't worry too much about errors (just throws them out to the caller, the console in this case). It's shorter and simpler and shows that simple programs can be simple to write, in Java as well.

<lang java>import java.io.*; public class Test {

 public static void main (String[] args) throws IOException {
   BufferedReader br = new BufferedReader(new FileReader("input.txt"));
   BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
   String line;
   while (line = br.readLine() != null) {
     bw.write(line);
     bw.newLine();
   }
   br.close();
   bw.close();
 }

}</lang>

Works with: Java version 7+

<lang java5>import java.nio.file.*; public class Copy{

  public static void main(String[] args) throws Exception{
     FileSystem fs = FileSystems.getDefault();
     Path in = fs.getPath("input.txt");
     Path out = fs.getPath("output.txt");
     Files.copy(in, out, StandardCopyOption.REPLACE_EXISTING);
  }

}</lang>

JavaScript

Works with: JScript

<lang javascript>var fso = new ActiveXObject("Scripting.FileSystemObject"); var ForReading = 1, ForWriting = 2; var f_in = fso.OpenTextFile('input.txt', ForReading); var f_out = fso.OpenTextFile('output.txt', ForWriting, true);

// for small files: // f_out.Write( f_in.ReadAll() );

while ( ! f_in.AtEndOfStream) {

   // ReadLine() does not include the newline char
   f_out.WriteLine( f_in.ReadLine() );

}

f_in.Close(); f_out.Close();</lang>

Works with: NodeJS

<lang javascript> var fs = require('fs'); require('util').pump(fs.createReadStream('input.txt', {flags:'r'}), fs.createWriteStream('output.txt', {flags:'w+'})); </lang>

K

<lang>`output.txt 0:0:`input.txt</lang>

Liberty BASIC

<lang lb>nomainwin

   open "input.txt" for input as #f1
       qtyBytes = lof( #f1)
       source$  = input$( #f1, qtyBytes)
   close #f1

   open "output.txt" for output as #f2
       #f2 source$;
   close #f2

   end</lang>

Lisaac

<lang Lisaac>Section Header

+ name := FILE_IO;

Section Public

- main <- (

 + e : ENTRY;
 + f : STD_FILE;
 + s : STRING;

 e := FILE_SYSTEM.get "input.txt";
 (e != NULL).if {
   f ?= e.open_read_only;
   (f != NULL).if {
     s := STRING.create(f.size);
     f.read s size (f.size);
     f.close;
   };
 };

 (s != NULL).if {
   e := FILE_SYSTEM.make_file "output.txt";
   (e != NULL).if {
     f ?= e.open;
     (f != NULL).if {
       f.write s from (s.lower) size (s.count);
       f.close;
     };
   };
 };

);</lang>

Logo

Works with: UCB Logo

<lang logo>to copy :from :to

 openread :from
 openwrite :to
 setread :from   
 setwrite :to
 until [eof?] [print readrawline]
 closeall

end

copy "input.txt "output.txt</lang>

Lua

<lang lua>io.open("output.txt", "w"):write(io.open("input.txt", "r"):read("*a"))</lang>

MAXScript

<lang maxscript>inFile = openFile "input.txt" outFile = createFile "output.txt" while not EOF inFile do (

   format "%" (readLine inFile) to:outFile

) close inFile close outFile</lang>

Mathematica

<lang Mathematica>SetDirectory@NotebookDirectory[]; If[FileExistsQ["output.txt"], DeleteFile["output.txt"], Print["No output yet"] ]; CopyFile["input.txt", "output.txt"]</lang>

mIRC Scripting Language

Works with: mIRC

<lang mirc>alias Write2FileAndReadIt { .write myfilename.txt Goodbye Mike! .echo -a Myfilename.txt contains: $read(myfilename.txt,1) }</lang>

Modula-3

<lang modula3>MODULE FileIO EXPORTS Main;

IMPORT IO, Rd, Wr;

<*FATAL ANY*>

VAR

 infile: Rd.T;
 outfile: Wr.T;
 txt: TEXT;
 

BEGIN

 infile := IO.OpenRead("input.txt");
 outfile := IO.OpenWrite("output.txt");
 txt := Rd.GetText(infile, LAST(CARDINAL));
 Wr.PutText(outfile, txt);
 Rd.Close(infile);
 Wr.Close(outfile);

END FileIO.</lang>

The code <*FATAL ANY*> is a pragma that tells the program to die if any exceptions (such as read/write errors) occur.

Objeck

<lang objeck>use IO;

bundle Default {

 class Test {
   function : Main(args : String[]) ~ Nil {
     len := File->Size("input.txt");
     buffer := Byte->New[len];
     in := FileReader->New("input.txt");
     if(in->IsOpen() <> Nil) {
       in->ReadBuffer(0, len, buffer);
       out := FileWriter->New("output.txt");
       if(out->IsOpen() <> Nil) {
         out->WriteBuffer(0, len, buffer);
         out->Close();
       };
       in->Close();
     };
   }
 }

}</lang>

Objective-C

Works with: Cocoa

Works with: GNUstep

Read the contents of input.txt and place it in output.txt, creating a file if needed:

<lang objc>NSData *data = [NSData dataWithContentsOfFile:@"input.txt"];

[data writeToFile:@"output.txt" atomically:YES];</lang>

Displayed without error checking to make it more clear. In real code you will need to add lot of error checking code, and maybe use dataWithContentsOfFile:error: if you want to get error information on failure. However, this code will mostly work correctly even if input does not exist or is not accessible. dataWithContentsOfFile: will return nil, and sending nil the message writeTofile:atomically: does nothing :-)

The second argument (atomically:YES) write the content to a temporary file, and rename the temporary file to the destination file, replacing existing file.

Object Pascal

For procedural code see the Delphi code, which is perfectly fine in ObjectPascal.

For a more object oriented style one can use a TFilestream:

<lang pascal>uses

 classes;

begin

 with TFileStream.Create('input.txt', fmOpenRead) do 
 try
   SaveToFile('output.txt');
 finally
   Free;
 end;

end;</lang>

OCaml

By line: <lang ocaml>let () =

 let ic = open_in "input.txt" in
 let oc = open_out "output.txt" in
 try
   while true do
     let s = input_line ic in
     output_string oc s;
     output_char oc '\n';
   done
 with End_of_file ->
   close_in ic;
   close_out oc;

</lang>

By character: <lang ocaml>let () =

 let ic = open_in "input.txt" in
 let oc = open_out "output.txt" in
 try
   while true do
     let c = input_char ic in
     output_char oc c
   done
 with End_of_file ->
   close_in ic;
   close_out oc;

</lang>

(Notice that ic and oc, of type in_channel and out_channel, are buffered)

OpenEdge/Progress

<lang Progress (OpenEdge ABL)>COPY-LOB FROM FILE "input.txt" TO FILE "output.txt".</lang>

Oz

<lang oz>declare

 class TextFile from Open.file Open.text end

 In = {New TextFile init(name:"input.txt")}
 Out = {New TextFile init(name:"output.txt" flags:[write text create truncate])}

 proc {CopyAll In Out}
    case {In getS($)} of false then skip
    [] Line then
       {Out putS(Line)}
       {CopyAll In Out}
    end
 end

in

 {CopyAll In Out}
 {Out close}
 {In close}</lang>

Pascal

The | FreePascal wiki gives a detailed description. For procedureal code see the Delphi examples. The ObjectPascal example is more OO coding style.

Perl

Works with: Perl version 5.8.8

<lang perl>#!/usr/bin/perl

open my $fh_in, '<', 'input.txt' or die "could not open <input.txt> for reading: $!"; open my $fh_out, '>', 'output.txt' or die "could not open <output.txt> for writing: $!";

1. '>' overwrites file, '>>' appends to file, just like in the shell

binmode $fh_out; # marks filehandle for binary content on systems where that matters

print $fh_out $_ while <$fh_in>;

1. prints current line to file associated with $fh_out filehandle

1. the same, less concise
2. while (<$fh_in>) {
3. print $fh_out $_;
4. };

close $fh_in; close $fh_out;</lang>

Perl has also a powerful mechanism in conjunction with opening files called IO disciplines. It allows you to automatically apply chainable transformations on the input and output. Mangling newlines, gzip (de)compression and character encoding are the most used examples.

Perl 6

<lang perl6>my $in = open "input.txt"; my $out = open "output.txt", :w; for $in.lines -> $line { $out.say($line); }</lang>

or, using the new slurp operator:

<lang perl6>(open "output.txt", :w).print(slurp "input.txt")</lang>

PHP

Works with: PHP version 4

<lang php><?php

if (!$in = fopen('input.txt', 'r')) {

   die('Could not open input file.');

}

if (!$out = fopen('output.txt', 'w')) {

   die('Could not open output file.');

}

while (!feof($in)) {

   $data = fread($in, 512);
   fwrite($out, $data);

}

fclose($out); fclose($in); ?></lang>

Works with: PHP version 5

<lang php><?php if ($contents = file_get_contents('input.txt')) {

   if (!file_put_contents('output.txt', $contents)) {
       echo('Could not write output file.');
   }

} else {

   echo('Could not open input file.');

} ?></lang>

PicoLisp

<lang PicoLisp>(in "input.txt"

  (out "output.txt"
     (echo) ) )</lang>

PL/I

<lang PL/I> declare in file, out file;

open file (in) title ('/INPUT.TXT,type(text),recsize(100)') input; open file (out) title ('/OUTPUT.TXT,type(text),recsize(100) output; do forever;

  get file (in)  edit (line) (L);
  put file (out) edit (line) (A);

end; </lang>

Pop11

Char by char copy:

<lang pop11>lvars i_stream = discin('input.txt'); lvars o_stream = discout('output.txt'); lvars c; while (i_stream() ->> c) /= termin do

   o_stream(c);

endwhile;</lang>

Low level block copy:

<lang pop11>lvars i_file = sysopen('input.txt', 0, true); lvars o_file = syscreate('output.txt', 1, true); lvars buff = inits(4096); lvars i; while (sysread(i_file, buff, length(buff)) ->> i) > 0 do

   syswrite(o_file, buff, i);

endwhile;</lang>

PowerShell

Read the input file then pipe it's contents to output file. Assumes that the files are in the same folder that the script is executing in. <lang PowerShell>Get-Content $PWD\input.txt | Out-File $PWD\output.txt</lang>

Using an alternate cmdlet to write the file <lang PowerShell>Get-Content $PWD\input.txt | Set-Content $PWD\output.txt</lang>

PureBasic

Basic file copy <lang PureBasic>CopyFile("input.txt","output.txt")</lang>

Line by line <lang PureBasic>in = ReadFile(#PB_Any,"input.txt") If in

 out = CreateFile(#PB_Any,"output.txt")
 If out
   Define MyLine$
   While Not Eof(in)
     MyLine$ = ReadString(in) 
     WriteString(out,MyLine$) 
   Wend
   CloseFile(out)
 EndIf
 CloseFile(in)

EndIf</lang>

Reading & writing the complete file in one pass <lang PureBasic>If ReadFile(0,"input.txt")

 Define MyLine$, *Buffer, length
 length=FileSize("input.txt")
 *Buffer = AllocateMemory(length)
 If *Buffer   
   If OpenFile(1,"output.txt")
     ReadData(0, *Buffer, length)
     WriteData(1, *Buffer, length)
     CloseFile(1)
   EndIf
   FreeMemory(*Buffer)
 EndIf
 CloseFile(0)

EndIf</lang>

Python

The following use of the standard libraries shutil.copyfile is to be preferred. (Current source code ensures that failure to open files raises appropriate exceptions, a restricted buffer is used to copy the files using binary mode, and any used file descriptors are always closed).

<lang python>import shutil shutil.copyfile('input.txt', 'output.txt')</lang>

However the following example shows how one would do file I/O of other sorts:

<lang python>infile = open('input.txt', 'r') outfile = open('output.txt', 'w') for line in infile:

  outfile.write(line)

outfile.close() infile.close()</lang>

This does no error checking. A more robust program would wrap each open with exception handling blocks:

<lang python>import sys try:

   infile = open('input.txt', 'r')

except IOError:

   print >> sys.stderr, "Unable to open input.txt for input"
   sys.exit(1)

try:

   outfile = open('output.txt', 'w')

except IOError:

   print >> sys.stderr, "Unable to open output.txt for output"
   sys.exit(1)

try: # for finally

   try: # for I/O
       for line in infile:
           outfile.write(line)
   except IOError, e:
       print >> sys.stderr, "Some I/O Error occurred (reading from input.txt or writing to output.txt)"

finally:

   infile.close()
   outfile.close()</lang>

In Python 2.6 (or 2.5 if we use from __future__ import with_statement) we can more simply write:

<lang python>import sys try:

   with open('input.txt') as infile:
       with open('output.txt', 'w') as outfile:
           for line in infile:
               outfile.write(line)

except IOError:

   print >> sys.stderr, "Some I/O Error occurred"
   sys.exit(1)</lang>

The files will automatically be closed on exit of their with: blocks. (Thus even if an I/O error occurred while reading the middle of the input file we are assured that the .close() method will have been called on each of the two files.

R

If files are textual we can use readLines ("-1" means "read until the end")

<lang R>src <- file("input.txt", "r") dest <- file("output.txt", "w")

fc <- readLines(src, -1) writeLines(fc, dest) close(src); close(dest)</lang>

If the files are not textual but "generic":

<lang R>src <- file("input.txt", "rb") dest <- file("output.txt", "wb")

while( length(v <- readBin(src, "raw")) > 0 ) {

 writeBin(v, dest) 

} close(src); close(dest)</lang>

Another simpler way is to use file.copy

<lang R>file.copy("input.txt", "output.txt", overwrite = FALSE)</lang>

RapidQ

File I/O is one of the things where RapidQ differs from standard Basic. RapidQ uses file streams.

The first version copies text line by line, as in the BASIC example.

<lang rapidq>$INCLUDE "rapidq.inc"

DIM File1 AS QFileStream DIM File2 AS QFileStream

File1.Open("input.txt", fmOpenRead) File2.Open("output.txt", fmCreate)

WHILE NOT File1.EOF

   data$ = File1.ReadLine
   File2.WriteLine(data$)

WEND

File1.Close File2.Close</lang>

When just copying data, the code can be simplified by using the CopyFrom method.
(The second parameter for CopyFrom is number of bytes to copy, 0 = copy the whole file.)

<lang rapidq>$INCLUDE "rapidq.inc"

DIM File1 AS QFileStream DIM File2 AS QFileStream

File1.Open("input.txt", fmOpenRead) File2.Open("output.txt", fmCreate)

File2.CopyFrom(File1, 0)

File1.Close File2.Close</lang>

Raven

<lang raven>'input.txt' read 'output.txt' write</lang>

REALbasic

<lang realbasic> Sub WriteToFile(Extends input As FolderItem, output As FolderItem)

 Dim tis As TextInputStream
 Dim tos As TextOutputStream
 tis = tis.Open(input)
 tos = tos.Create(output)
 While Not tis.EOF
   tos.WriteLine(tis.ReadLine)
 Wend
 tis.Close
 tos.Close

End Sub </lang>

REBOL

<lang REBOL>write %output.txt read %input.txt

No line translations

write/binary %output.txt read/binary %input.txt

Save a web page

write/binary %output.html read http://rosettacode.org </lang>

Retro

<lang Retro>with files' here dup "input.txt" slurp "output.txt" spew</lang>

REXX

In rexx, filename association is used rather than numeric stream numbers and explicit file opening is not required.

version 1

<lang rexx> /*REXX program to read a file and store the contents into an output file*/

ifid='input.txt' /*name of the input file. */ ofid='output.txt /*name of the output file. */

 do while lines(ifid)\==0             /*read until finished.           */
 y=linein(ifid)                       /* read a record from input.     */
 call lineout ofid,y                  /*write a record  to  output.nt. */
 end

</lang>

version 2

<lang rexx> /*REXX program to read a file and store the contents into an output file*/

ifid='input.txt' /*name of the input file. */ ofid='output.txt /*name of the output file. */

 do while lines(ifid)\==0             /*read until finished.           */
 call lineout ofid,linein(ifid)       /*read & write in one statement. */
 end

</lang>

Ruby

This task is easy, with 'fileutils' from the standard library.

<lang ruby>require 'fileutils' FileUtils.copy_file 'input.txt', 'output.txt'</lang>

It also works with open IO handles.

<lang ruby>File.open('input.txt', 'rb') do |i|

 File.open('output.txt', 'wb') do |o|
   FileUtils.copy_stream(i, o)
 end

end</lang>

---

We can also do IO with only the core library.

<lang ruby>File.open('input.txt', 'rb') do |i|

 File.open('output.txt', 'wb') do |o|
   buf = ""
   bufsiz = (i.stat.blksize or 16384)
   while i.read(bufsiz, buf) do o.write(buf) end
 end

end</lang>

• The best buffer size is i.stat.blksize. Some platforms return nil there, so we guess 16384 bytes.

The shortest way to copy a file, without coding any loops and without requiring any libraries, is to read the entire file into memory.

<lang ruby>irb(main):001:0> open('output.txt', 'w') {|f| f << IO.read('input.txt')} => #<File:output.txt (closed)></lang>

But this has disadvantages:

• There was no 'b' flag, so it might not work with binary files on some platforms. With a 'b' flag, the code would be open('output.txt', 'wb') {|f| f << IO.read('input.txt', mode: 'rb')}, but this requires Ruby 1.9. (There is no way to pass 'b' flag to IO.read with Ruby 1.8.)
• If the file is too large, we fail to allocate enough memory.

---

Ruby 1.9 has a new core method, IO.copy_stream. With MRI 1.9, IO.copy_stream might use Linux's sendfile(2) system call, or it might loop with a buffer of 16384 bytes.

Works with: Ruby version 1.9

<lang ruby>IO.copy_stream('input.txt', 'output.txt')

1. It also works with open IO handles.

File.open('input.txt', 'rb') do |i|

 File.open('output.txt', 'wb') do |o|
   IO.copy_stream(i, o)
 end

end</lang>

FileUtils knows about IO.copy_stream; so if you use FileUtils, then your program uses IO.copy_stream with Ruby 1.9, but still works with older Ruby versions.

Scala

Requires Java 7

<lang scala>

import java.nio.file._

val input = Paths.get("input.txt") val output = Paths.get("output.txt")

Files.copy(input, output) </lang>

Scheme

Character by character copy<lang scheme>; Open ports for the input and output files (define in-file (open-input-file "input.txt")) (define out-file (open-output-file "output.txt"))

Read and write characters from the input file

to the output file one by one until end of file

(do ((c (read-char in-file) (read-char in-file)))

       ((eof-object? c))
       (write-char c out-file))

Close the ports

(close-input-port in-file) (close-output-port out-file) </lang>

Seed7

The library osfiles.s7i contains the function copyFile which can be used to copy a source file to a destination.

<lang seed7>$ include "seed7_05.s7i";

 include "osfiles.s7i";

const proc: main is func

 begin
   copyFile("input.txt", "output.txt");
 end func;</lang>

Slate

<lang slate>(File newNamed: 'input.txt' &mode: File Read) sessionDo: [| :in |

 (File newNamed: 'output.txt' &mode: File CreateWrite) sessionDo: [| :out |
   in >> out]]</lang>

Smalltalk

<lang smalltalk>| in out | in := FileStream open: 'input.txt' mode: FileStream read. out := FileStream open: 'output.txt' mode: FileStream write. [ in atEnd ]

 whileFalse: [
    out nextPut: (in next)
 ]</lang>

SNOBOL4

<lang snobol4>

       input(.input,5,,'input.txt')
       output(.output,6,,'output.txt')

while output = input :s(while) end</lang>

Standard ML

Works with: SML/NJ version 110.59

<lang sml>fun copyFile (from, to) = let

 val instream = TextIO.openIn from
 val outstream = TextIO.openOut to
 val () = TextIO.output (outstream, TextIO.inputAll instream)
 val () = TextIO.closeIn instream
 val () = TextIO.closeOut outstream

in

 true

end handle _ => false;</lang>

Tcl

Works with: tclsh

Works with: eTcl

Works with: wish

Works with: tixwish

<lang tcl>set in [open "input.txt" r] set out [open "output.txt" w]

1. Obviously, arbitrary transformations could be added to the data at this point

puts -nonewline $out [read $in] close $in close $out</lang> For larger files, it is better to use the fcopy command, though in general this restricts what operations can be performed rather more (only encoding and end-of-line translations are possible, though not shown here): <lang tcl>set in [open "input.txt" r] set out [open "output.txt" w] fcopy $in $out close $in close $out</lang>

Or the minimal version if we don't need any processing of the data at all: <lang tcl>file copy input.txt output.txt</lang>

Other File I/O:

<lang tcl>#open file for writing set myfile [open "README.TXT" w]

1. write something to the file

puts $myfile "This is line 1, so hello world...."

1. close the file

close $myfile</lang>

<lang tcl>#open file for reading set myfile [open "README.TXT" r]

1. read something from the file

gets $myfile mydata

1. show what was read from the file
2. should print "This is line1, so hello world...."

puts $mydata

1. close the file

close $myfile</lang>

Toka

This is one method, which works with any type of file:

<lang toka>( source dest -- ) {

 value| source dest size buffer |
 {
   {
     [ "W" file.open to dest ] is open-dest
     [ "R" file.open to source ] is open-source
     [ open-dest open-source ]
   } is open-files
   {
     [ source file.size to size ] is obtain-size
     [ size malloc to buffer ] is allocate-buffer
     [ obtain-size allocate-buffer ]
   } is create-buffer
   [ source dest and 0 <> ] is check
   [ open-files create-buffer check ]
 } is prepare
 [ source buffer size file.read drop ] is read-source
 [ dest buffer size file.write drop ] is write-dest
 [ source file.close dest file.close ] is close-files
 [ prepare [ read-source write-dest close-files ] ifTrue ]

} is copy-file</lang>

And a much simpler way for plain text files, making use of file.slurp:

<lang toka>[ ( source dest -- )

 swap file.slurp dup 0 <>
 [ >r "W" file.open dup r> string.getLength file.write drop file.close ] ifTrue

] is copy-file</lang>

And a test:

<lang toka>" input.txt" " output.txt" copy-file</lang>

UNIX Shell

Using the 'read' built-in

• Hint: mksh(1) manual says, "If read is run in a loop such as while read foo; do ...; done then leading whitespace will be removed (IFS) and backslashes processed. You might want to use while IFS= read -r foo; do ...; done for pristine I/O."
• Caveat: output.txt will end with a newline, whether or not input.txt ended with one.

<lang bash>#!/bin/sh while IFS= read -r a; do

   printf '%s\n' "$a"

done <input.txt >output.txt</lang>

Another way, using the 'cat' program

<lang bash>#!/bin/sh cat input.txt >output.txt</lang>

Yet another way, using the 'cp' utility <lang bash>#!/bin/sh cp input.txt output.txt</lang>

Ursala

I/O in Ursala is meant to be handled transparently by the run time system. The application is passed the input files as an argument and expected to return the output files as a result.

Returning a copy of the input file with a new name causes it to be written as a new file. <lang Ursala>#import std

1. executable ('parameterized',)

fileio = ~command.files; &h.path.&h:= 'output.txt'!</lang>

VBScript

one liner (-2 for system default encoding) <lang vb>CreateObject("Scripting.FileSystemObject").OpenTextFile("output.txt",2,-2).Write CreateObject("Scripting.FileSystemObject").OpenTextFile("input.txt", 1, -2).ReadAll</lang>

Visual Basic .NET

Works with: Visual Basic .NET version 9.0+

<lang vbnet>'byte copy My.Computer.FileSystem.WriteAllBytes("output.txt", _

 My.Computer.FileSystem.ReadAllBytes("input.txt"), False)

'text copy Using input = IO.File.OpenText("input.txt"), _

     output As New IO.StreamWriter(IO.File.OpenWrite("output.txt"))
 output.Write(input.ReadToEnd)

End Using

'Line by line text copy Using input = IO.File.OpenText("input.txt"), _

     output As New IO.StreamWriter(IO.File.OpenWrite("output.txt"))
 Do Until input.EndOfStream
   output.WriteLine(input.ReadLine)
 Loop

End Using</lang>