Create a file: Difference between revisions

 

In this task, the job is to create a new empty file called "output.txt" of size 0 bytes

and an empty directory called "docs". This should be done twice: once "here", i.e. in the current working directory and once in the filesystem root.

 

=={{header|4DOS Batch}}==

mkdir docs

 

echos > \output.txt

 

=={{header|Ada}}==

* Use Streams_IO to write 0 bytes. File creation with Ada.Text_IO does not create 0 byte files (it inserts EOL/EOF).<br>

* The forward slash (/) notation works in Windows XP as well as Unix/Linux.

use Ada.Streams.Stream_IO, Ada.Directories;

 

Create_Directory("/docs");

 

=={{header|Aikido}}==

var sout = openout ("output.txt") // in current dir

sout.close()

mkdir ("/docs")

 

 

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

{{works with|ALGOL 68|Standard - no extensions to language used}}

It may be best to to use an operating system provided library.

 

INT errno;

 

errno := mkpage("input.txt",2);

 

=={{header|APL}}==

'\output.txt' ⎕ncreate ¯1+⌊/0,⎕nnums

⎕mkdir 'Docs'

 

=={{header|AppleScript}}==

 

Create a zero-byte text file on the startup disk (root directory). Note: the <code>close</code> command is a memory allocation housekeeping command that should be performed once file access is complete.

Create a new folder (directory) on the startup disk (root directory).

Create a zero-byte text file in the frontmost (open) Finder window.

Create a new folder (directory) in the frontmost (open) Finder window.

--[[User:Apl.way|Apl.way]] 21:20, 9 June 2010 (UTC)

 

=={{header|AutoHotkey}}==

FileCreateDir, docs

FileAppend,,c:\output.txt

 

=={{header|AWK}}==

printf "" > "output.txt"

printf "" > "/output.txt"

 

=={{header|BASIC}}==

CLOSE

OPEN "\output.txt" FOR OUTPUT AS 1

 

=={{header|Batch File}}==

 

 

=={{header|C}}==

ISO C (directory creation not supported):

 

int main() {

 

return 0;

 

 

{{works with|POSIX}}

 

int fd = open("output.txt", O_WRONLY|O_CREAT|O_TRUNC, 0640); /* rights 0640 for rw-r----- */

/* or equivalently:

close(fd);

 

 

return 0;

 

(for creation in the filesystem root, replace the filenames by "/output.txt" and "/docs")

 

 

 

 

 

=={{header|C sharp|C#}}==

 

using System.IO;

 

Directory.CreateDirectory(@"\docs");

}

 

=={{header|Clojure}}==

(.createNewFile (new File "output.txt"))

(.mkdir (new File "docs"))

(.createNewFile (File. (str (File/separator) "output.txt")))

 

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

but it is more common to use ''with-open-file'' which has better exception handling.

;; use the stream here

As lisp is capable of being run on many different platforms and no assumptions should be made about the filesystem there are functions to construct paths in a platform independent manner

(make-pathname :directory '(:absolute "docs")))))

So creating a file called ''output.txt'' with an absolute path in the root directory becomes:

(stream

(make-pathname :directory '(:absolute "") :name "output.txt")

 

On the other hand, if you may depend on the platform's pathname syntax then shorter notation may be used:

 

=={{header|D}}==

For file creation, std.file.write function & std.stream.file class are used.<br>

For dir creation, std.file.mkdir is used.

import std.stdio ;

import std.path ;

writefln("== test: File & Dir Creation ==") ;

testCreate("output.txt", "docs") ;

=={{header|DCL}}==

open/write output_file [000000]output.txt

create/directory [.docs]

 

=={{header|E}}==

 

<file:docs>.mkdir(null)

<file:///output.txt>.setBytes([])

 

=={{header|Euphoria}}==

 

-- In the current working directory

system("mkdir \\docs",2)

fn = open("\\output.txt","w")

 

=={{header|Factor}}==

 

"output.txt" "/output.txt" [ touch-file ] bi@

 

=={{header|Fancy}}==

# create '/docs', then './docs'

Directory create: (dir ++ "docs")

f writeln: "hello, world!"

}

 

=={{header|Forth}}==

There is no means to create directories in ANS Forth.

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

Don't know a way of creating directories in Fortran

CLOSE (UNIT=5)

OPEN (UNIT=5, FILE="/output.txt", STATUS="NEW") ! Root directory

=={{header|Go}}==

 

import (

 

func createFile(fn string) {

if err != nil {

fmt.Println(err)

createDir("docs")

createDir("/docs")

 

=={{header|Groovy}}==

new File(File.separator + "output.txt").createNewFile()

new File("docs").mkdir()

 

=={{header|Haskell}}==

 

 

createFile name = writeFile name ""

createDirectory "docs"

createFile "/output.txt"

 

=={{header|HicEst}}==

OPEN(FILE="output.txt", "NEW") ! in current directory

 

SYSTEM(DIR="C:\docs") ! create C:\docs if not existent, make it current

 

=={{header|Icon}} and {{header|Unicon}}==

Icon does not support 'mkdir' - otherwise the Unicon code below will work. A work around would be to use 'system' to invoke command line to create a directory.

close(open(f := dir || "input.txt","w")) |stop("failure for open ",f)

mkdir(f := dir || "docs") |stop("failure for mkdir ",f)

Note: Icon and Unicon accept both / and \ for directory separators.

 

The conjunction <tt>!:</tt> with a scalar <tt>1</tt> to the left (<tt>1!:</tt>) provides the underlying cross-platform support for [http://www.jsoftware.com/help/dictionary/dx001.htm working with files].

 

 

However a number of libraries provide a more convenient/conventional interface to that underlying functionality.

NB. create two empty files named /output.txt and output.txt

'' fwrite '/output.txt' ; 'output.txt'

require 'general/dirutils' NB. addon package

NB. create two directories: /docs and docs:

 

Finally note that writing a file in J creates that file. In typical use, files are referred to by name, and the entire contents of the file are written. (Appends and partial writes are also supported but they are more complicated than the typical case.)

 

=={{header|Java}}==

public class CreateFileTest {

public static void main(String args[]) {

}

}

 

=={{header|JavaScript}}==

 

 

 

=={{header|Lua}}==

==== Create File ====

 

 

==== Create Directory ====

This solution sends the command to the OS shell.

 

 

SetDirectory@NotebookDirectory[];

t = OpenWrite["output.txt"]

Close[t]

Close[s]

 

 

=={{header|MAXScript}}==

f = createFile "output.txt"

close f

f = createFile "\output.txt"

close f

 

=={{header|Modula-3}}==

 

IMPORT FS, File, OSError, IO, Stdio;

| OSError.E => IO.Put("Error creating file or directory.\n", Stdio.stderr);

END;

 

 

 

 

=={{header|Objeck}}==

use IO;

 

}

}

 

=={{header|OCaml}}==

 

close_out oc;;

- : unit = ()

 

# Unix.mkdir "docs" 0o750 ;; (* rights 0o750 for rwxr-x--- *)

 

(for creation in the filesystem root, replace the filenames by "/output.txt" and "/docs")

 

=={{header|Oz}}==

File = {New Open.file init(name:Dir#"output.txt" flags:[create])}

in

{File close}

{OS.mkDir Dir#"docs" ['S_IRUSR' 'S_IWUSR' 'S_IXUSR' 'S_IXGRP']}

 

 

=={{header|Pascal}}==

The Pascal & Delphi Standard Libraries support all of this functionality.

 

program in out;

 

 

end;

 

=={{header|Perl}}==

{ # here

open my $fh, '>', 'output.txt';

open my $fh, '>', catfile rootdir, 'output.txt';

mkdir catfile rootdir, 'docs';

 

'''Without Perl Modules'''

 

Current directory

 

Root directory

 

 

 

 

=={{header|PHP}}==

touch('output.txt');

mkdir('docs');

touch('/output.txt');

mkdir('/docs');

 

=={{header|PicoLisp}}==

(call 'mkdir "docs") # Call external

(out "/output.txt")

 

=={{header|Pike}}==

 

int main(){

write_file("input.txt","",0100);

write_file("/input.txt","",0100);

 

=={{header|PL/I}}==

open file (output) title ('/OUTPUT.TXT,type(text),recsize(100)' );

close file (output);

 

=={{header|PowerShell}}==

New-Item \output.txt -ItemType File

New-Item docs -ItemType Directory

 

=={{header|PureBasic}}==

 

CreateDirectory("docs")

CreateFile(0,"/output.txt"):CloseFile(0)

 

=={{header|Python}}==

open(directory + 'output.txt', 'w').close() # create /output.txt, then ./output.txt

 

{{works with|Python|2.5}}

Exception-safe way to create file:

 

import os

def create(directory):

create(".") # current directory

 

=={{header|R}}==

close(f)

 

 

success <- dir.create("docs")

 

=={{header|Raven}}==

 

str 'output.txt' write

str '/output.txt' write

'docs' mkdir

 

=={{header|REBOL}}==

 

 

write %output.txt ""

write %/output.txt ""

make-dir %/docs/

 

=={{header|Retro}}==

There are no facilities in Retro to create directories.

 

 

=={{header|REXX}}==

 

=={{header|Ruby}}==

Dir.mkdir(dir + 'docs') # create '/docs', then './docs'

File.open(dir + 'output.txt', 'w') {} # create empty file /output.txt, then ./output.txt

 

=={{header|Scheme}}==

Results:

> file output.txt

/output.txt: empty

I am not aware of any '''standard''' way of creating directories in Scheme.

 

=={{header|Slate}}==

File creation locally:

 

File creation at root:

 

=={{header|Smalltalk}}==

[[Squeak]] has no notion of 'current directory' because it isn't tied to the shell that created it.

 

 

In [[GNU Smalltalk]] you can do instead:

 

ws close.

Directory create: 'docs'.

ws := (File name: '/output.txt') writeStream.

ws close.

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

 

* output(.file,1,,'output.txt'); endfile(1) ;* CSnobol

host(1,'mkdir docs')

* output(.file,1,,'/output.txt'); endfile(1) ;* CSnobol

host(1,'mkdir /docs')

 

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

 

TextIO.closeOut out

end;

 

 

(for creation in the filesystem root, replace the filenames by "/output.txt" and "/docs")

 

=={{header|Tcl}}==

Assuming that we're supposed to create two files and two directories (one each here and one each in the file system root) and further assuming that the code is supposed to be portable, i.e. work on win, linux, MacOS (the task is really not clear):

 

close [open [file nativename /output.txt] w]

 

file mkdir docs

 

=={{header|Toka}}==

 

" output.txt" "W" file.open file.close

" /output.txt" "W" file.open file.close

( Create the directories with permissions set to 777)

" docs" &777 mkdir

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

- create file

- create directory

ERROR/STOP CREATE ("docs",project,-std-)

 

=={{header|Vedit macro language}}==

When closing a file, Vedit saves it only if it has been modified. Therefore, in order to create an empty file, we first insert a character in the file and then delete it.

File_Open("input.txt") Ins_Char(' ') Del_Char(-1) Buf_Close()

File_Mkdir("docs")

// In the root directory

File_Open("/input.txt") Ins_Char(' ') Del_Char(-1) Buf_Close()

 

=={{header|Visual Basic .NET}}==

 

{{works with|Visual Basic .NET|9.0+}}

IO.Directory.CreateDirectory("docs")

IO.File.Create("output.txt").Close()

'Root, platform independent

IO.Directory.CreateDirectory(IO.Path.DirectorySeparatorChar & "docs")

 

 

 

 

 

=={{header|X86 Assembly}}==

{{works with|NASM|Linux}}

%define sys_mkdir 39

%define sys_creat 8

 

section .data