Write entire file: Difference between revisions

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

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program writeFile64.s */

.include "../includeARM64.inc"

=={{header|Action!}}==

open (1,"D:FILE.TXT",8,0)

printde(1,"My string")

close(1)

return

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

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

==={{header|Applesoft BASIC}}===

20 F$ = "OUTPUT.TXT"

30 PRINT D$"OPEN"F$

70 PRINT D$"WRITE"F$

80 PRINT "THIS STRING IS TO BE WRITTEN TO THE FILE"

==={{header|BASIC256}}===

open f, "output.txt"

write f, "This string is to be written to the file"

==={{header|QBasic}}===

{{works with|FreeBASIC}}

OPEN "output.txt" FOR OUTPUT AS #f

PRINT #f, "This string is to be written to the file"

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

{{works with|QBasic}}

{{works with|FreeBASIC}}

print #1, "This string is to be written to the file"

==={{header|True BASIC}}===

PRINT #1: "This string is to be written to the file"

CLOSE #1

=={{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 sharp|C#}}==

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

using namespace std;

file.close();

return 0;

=={{header|Clojure}}==

=={{header|COBOL}}==

IDENTIFICATION DIVISION.

PROGRAM-ID. Overwrite.

END-PROGRAM.

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

{{libheader| System.IoUtils}}

{{Trans|C#}}

program Write_entire_file;

begin

TFile.WriteAllText('filename.txt', 'This file contains a string.');

=={{header|Elena}}==

ELENA 4.x :

public program()

{

File.assign("filename.txt").saveContent("This file contains a string.")

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

=={{header|Free Pascal}}==

''See also: [[#Pascal]]''

{$mode objFPC} // for exception treatment

uses

close(FD);

end;

=={{header|FreeBASIC}}==

Open "output.txt" For Output As #1

Print #1, "This is a string"

=={{header|Frink}}==

w = new Writer["test.txt"]

w.print["I am the captain now."]

w.close[]

=={{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|Mathematica}}/{{header|Wolfram Language}}==

=={{header|Nanoquery}}==

=={{header|Nim}}==

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

=={{header|Objeck}}==

class WriteFile {

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

}

=={{header|OCaml}}==

let oc = open_out filename in

output_string oc s;

let filename = "test.txt" in

let s = String.init 26 (fun i -> char_of_int (i + int_of_char 'A')) in

=={{header|Pascal}}==

In Standard Pascal, a list of identifiers in the program header sets up a list of file handlers.

program overwriteFile(FD);

begin

writeLn(FD, 'Whasup?');

close(FD);

In some environments, it is the caller’s sole responsibility to invoke the program properly.

I. e., the program above could be invoked on a Bourne-again shell in this fashion:

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

<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: #004080;">integer</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">write_lines</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"file.txt"</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"line 1\nline 2"</span><span style="color: #0000FF;">})</span>

<span style="color: #008080;">if</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">crash</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"error"</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

lines can also be {"line 1","line 2"} (note that a \n is appended to each line) or other multiline/triplequoted text.<br>

See also open(), puts(), printf(), (neither of which add any \n), close(), temp_file(), create_directory()...

=={{header|PHP}}==

=={{header|PicoLisp}}==

=={{header|Pike}}==

=={{header|PowerShell}}==

Writes all running process details to a file in the current directory.

Get-Process | Out-File -FilePath .\ProcessList.txt

=={{header|PureBasic}}==

EnableExplicit

CloseConsole()

EndIf

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

=={{header|Python}}==

Starting in Python 3.4, we can use <code>pathlib</code> to reduce boilerplate:

Path(filename).write_text(any_string)

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

(formerly Perl 6)

or

=={{header|RATFOR}}==

# Program to overwrite an existing file

end

=={{header|REXX}}==

===version 1===

/*REXX*/

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

use std::io::Write;

write!(file, "{}", data)?;

Ok(())

=={{header|Scala}}==

object Main extends App {

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

close()}

=={{header|SenseTalk}}==

=={{header|Sidef}}==

With error handling:

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

Without error handling:

=={{header|Smalltalk}}==

{{works with | Smalltalk/X}}

=={{header|SPL}}==

=={{header|Standard ML}}==

(fn strm =>

=={{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|Visual Basic .NET}}==

{{trans|C#}}

Sub Main()

End Module

=={{header|Wren}}==

The easiest way to overwrite a file in Wren is to 'create' it again which truncates the existing contents.

// create a text file

// check it worked

{{out}}

=={{header|XLISP}}==

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

=={{header|XPL0}}==

Text(3, "This is a string.");

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