Write entire file: Difference between revisions

The reverse of [[Read entire file]]—for when you want to update or create a file which you would read in its entirety all at once.

<br><br>

 

=={{header|Ada}}==

 

 

procedure Write_Whole_File is

Close (F);

end Write_Whole_File;

 

=={{header|ALGOL 68}}==

STRING output file name = "output.txt";

open( output, output file name, stand out channel ) = 0

# unable to open the output file #

print( ( "Cannot open ", output file name, newline ) )

 

=={{header|AutoHotkey}}==

file.Write("this is a test string")

=={{header|AWK}}==

# syntax: GAWK -f WRITE_ENTIRE_FILE.AWK

BEGIN {

exit(0)

}

 

=={{header|BaCon}}==

String:

 

Binary:

 

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

PRINT#file%, text$

 

=={{header|Bracmat}}==

 

=={{header|C}}==

 

=== Dirty solution ===

* Write Entire File -- RossetaCode -- dirty hackish solution

*/

freopen("sample.txt","wb",stdout));

}

=== Standard function fwrite() ===

* Write Entire File -- RossetaCode -- ASCII version with BUFFERED files

*/

return EXIT_FAILURE;

}

=== POSIX function write() ===

* Write Entire File -- RossetaCode -- plain POSIX write() from io.h

*/

return 1;

}

 

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

using namespace std;

 

file.close();

return 0;

 

=={{header|Clojure}}==

 

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

:direction :output

:if-exists :supersede

:if-does-not-exist :create)

 

=={{header|D}}==

 

void main() {

auto file = File("new.txt", "wb");

file.writeln("Hello World!");

 

=={{header|Elena}}==

 

=={{header|Elixir}}==

 

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

 

=={{header|Factor}}==

 

=={{header|Fortran}}==

Where F is an integer with a value such as 10 (these days not being 5, standard input, nor 6, standard output), the I/O unit number. "REPLACE" means create the file if it does not exist, otherwise delete the existing file and create a new one of that name. The WRITE statement may present a single (large?) item, a list of items, and possibly there would be a series of WRITE statements if there is no need to do the deed via one WRITE only.

WRITE (F,*) "Whatever you like."

Earlier Fortran might have other predefined unit numbers, for a card punch, paper tape, lineprinter, and so on, according to the installation. For a disc file, there may be no facility to name the file within Fortran itself as in the example OPEN statement because there may be no OPEN statement. Fortran IV used a DEFINE FILE statement, for example, which specified the record length and number of records in the file. As constants. File naming would instead be done by commands to the operating system when the prog. is started, as with the DD statement of JCL (Job Control Language) of IBM mainframes, and this would have its own jargon for NEW, OLD, REPLACE and what to do when the step finishes: DISP=KEEP, perhaps.

 

 

Option FORM="BINARY" ''does'' allow the reading or writing of however many records are needed to satisfy the I/O list, but, this is not a standard usage.

 

=={{header|FreeBASIC}}==

 

Open "output.txt" For Output As #1

Print #1, "This is a string"

 

=={{header|Gambas}}==

 

File.Save(User.home &/ "test.txt", "(Over)write a file so that it contains a string.")

 

 

=={{header|Go}}==

 

func main() {

ioutil.WriteFile("path/to/your.file", []byte("data"), 0644)

 

=={{header|Groovy}}==

that can be

splitted over lines

"""

 

=={{header|Haskell}}==

main = do

putStrLn "Enter a string!"

putStrLn "Where do you want to store this string ?"

myFile <- getLine

 

=={{header|J}}==

 

or,

 

 

=={{header|Java}}==

 

public class Test {

}

}

 

=={{header|Julia}}==

f = open(filename, "w")

write(f, data)

end

 

 

=={{header|Kotlin}}==

 

import java.io.File

val text = "empty vessels make most noise"

File("output.txt").writeText(text)

 

=={{header|Lingo}}==

-- Saves string as file

-- @param {string} tFile

fp.closeFile()

return true

 

=={{header|LiveCode}}==

This will create a file "TestFile.txt" or overwrite it if it already exists. This is the shortest method for file I/O in LiveCode, but not the only method.

put "this is a string" into URL "file:~/Desktop/TestFile.txt"

 

=={{header|Lua}}==

local f = io.open(filename, 'w')

f:write(data)

end

 

 

=={{header|Maple}}==

 

 

 

=={{header|Nim}}==

writeFile("filename.txt", "An arbitrary string")

 

=={{header|Objeck}}==

 

class WriteFile {

writer→WriteString("this is a test string");

}

 

=={{header|Perl}}==

The modern recommended way, is to use one of these CPAN modules:

 

 

 

Traditional way, in case using CPAN modules is not an option:

 

print $fh $data;

 

=={{header|Phix}}==

 

=={{header|PHP}}==

 

=={{header|PicoLisp}}==

 

=={{header|PureBasic}}==

EnableExplicit

 

CloseConsole()

EndIf

 

{{out|Output (contents of 'output.exe')}}

 

=={{header|Python}}==

 

=={{header|Racket}}==

This only replaces the file if it exists, otherwise it writes a new file. Use <tt>'truncate</tt> to overwrite the new contents into the existing file.

(with-output-to-file "/tmp/out-file.txt" #:exists 'replace

 

=={{header|REXX}}==

===version 1===

'erase' of

s=copies('1234567890',10000)

Call charout of,s

Call lineout of

{{out}}

<pre>100000 100000</pre>

===version 2===

This REXX version doesn't depend on any (operating system) host commands.

oFID= 'OUTPUT.DAT' /*name of the output file to be used. */

/* [↓] 50 bytes, including the fences.*/

call charout oFID, copies($,1000), 1 /*write the longish text to the file. */

/* [↑] the "1" writes text ──► rec #1*/

<br><br>

 

=={{header|Ring}}==

write("myfile.txt","Hello, World!")

 

=={{header|Ruby}}==

The file is closed at the end of the block.

=={{header|Scala}}==

 

object Main extends App {

" frictional radial anti-stabilizer vectronize from the flumberboozle to the XKG virtual port?")

close()}

=={{header|Sidef}}==

With error handling:

file.open_w(\var fh, \var err) || die "Can't open #{file}: #{err}"

Without error handling:

 

=={{header|SPL}}==

 

=={{header|Tcl}}==

 

set fd [open $filename w] ;# truncate if exists, else create

try {

close $fd

}

 

A more elaborate version of this procedure might take optional arguments to pass to <tt>fconfigure</tt> (such as encoding) or <tt>open</tt> (such as permissions).

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

content="new text that will overwrite content of myfile"

IF (status=="CREATE") ERROR/STOP CREATE ("myfile",seq-o,-std-)

ENDLOOP

=={{header|VBA}}==

 

Option Explicit

 

Print #1, Text

Close #Nb

 

=={{header|VBScript}}==

Text file created or overwritten in the same folder as the script.

Set objFSO = CreateObject("Scripting.FileSystemObject")

 

 

Set objFSO = Nothing

 

=={{header|XLISP}}==

(write "(Over)write a file so that it contains a string." n)

 

=={{header|Xtend}}==

package com.rosetta.example

 

}

}

 

=={{header|Yabasic}}==

print #1 "This is a string"

 

=={{header|zkl}}==

File("foo","wb").write("this is a test",1,2,3); //-->17

 

f:=File("bar",wb");

data.pump(f,g); // use g to process data as it is written to file