Create a file: Difference between revisions

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

{{trans|Python}}

File(directory‘output.txt’, ‘w’) // create /output.txt, then ./output.txt

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

mkdir docs

echos > \output.txt

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program createDirFic64.s */

.include "../includeARM64.inc"

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

The attached result has been obtained under DOS 2.5.

CHAR ARRAY line(255)

BYTE dev=[1]

PrintF("Dir ""%S""%E",filter)

Dir(filter)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Create_a_file.png Screenshot from Atari 8-bit computer]

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

void

mkdir(text p)

return 0;

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

=={{header|Arturo}}==

docs: "docs"

write join.path ["/" output] ""

=={{header|AutoHotkey}}==

FileCreateDir, docs

FileAppend,,c:\output.txt

=={{header|AWK}}==

printf "" > "output.txt"

close("output.txt")

system("mkdir docs")

system("mkdir /docs")

=={{header|Axe}}==

Since the TI-OS does not have a true filesystem, this task is emulated using an application variable instead of a file.

=={{header|BASIC}}==

CLOSE

OPEN "\output.txt" FOR OUTPUT AS 1

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

There are disk volumes, but no folders in DOS 3.3.

==={{header|BaCon}}===

TRAP LOCAL

LABEL report2

{{out}}

Even still, the empty file will still cause Commodore DOS to allocate 1 data block to the file, as reported in a directory listing.

10 rem create a file

20 open 10,8,10,"0:output.txt,seq,write"

50 rem check device status for error

60 open 15,8,15:input#15,a,b$,c,d:print a;b$;c;d:close 15

<pre>

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

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

{{works with|BBC BASIC for Windows}}

CLOSE #OPENOUT("\output.txt")

*MKDIR docs

=={{header|Blue}}==

Linux/x86-64. If you really want to create a file and dir in the root, prefix the paths with a slash.

: syscall ( num:eax -- result:eax ) syscall ;

make-docs-directory

bye

=={{header|BQN}}==

May require elevated privileges to run correctly. Paths are relative to the script's path by default, but can be resolved relative to the shell's working directory with <code>•wdpath •file.At path</code>.

"/output.txt" •file.Chars ""

•file.CreateDir "docs"

=={{header|Bracmat}}==

Or

In the latter case the file is still open, so unless the file is implicitly flushed and closed by ending the Bracmat program, you would want to close it explicitly:

To create a directory we are dependent on the underlying OS. In DOS:

And in the file system root:

=={{header|C}}==

=== ISO C ===

ISO C (directory creation not supported):

int main() {

return 0;

=== POSIX ===

{{works with|POSIX}}

#include <unistd.h>

#include <fcntl.h>

return 0;

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

First, a solution with the C runtime functions <code>_creat</code> and <code>_mkdir</code>.

#include <io.h>

#include <sys/stat.h>

return 0;

Another solution with the kernel32 API functions <code>CreateFile</code> and <code>CreateDirectory</code>.

#include <stdio.h>

return 0;

=== OS/2 ===

Using the OS/2 API functions <code>DosOpen</code> and <code>DosMkDir</code>.

int main(void) {

return 0;

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

using System.IO;

Directory.CreateDirectory(@"\docs");

}

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

Uses some Microsoft library:

#include <fstream>

return 0;

A cross-platform solution using C++17

#include <fstream>

fs::create_directory("docs");

fs::create_directory("/docs");

=={{header|ChucK}}==

This creates a file in root:

FileIO text;

text.open("output.txt", FileIO.WRITE);

=={{header|Clojure}}==

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

(.mkdir (new File "docs"))

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

=={{header|COBOL}}==

{{works with|GnuCOBOL}} and other compilers with the system call extensions

program-id. create-a-file.

.

{{out}}

<pre>

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

{{works with| BlackBox Component Builder}}

MODULE CreateFile;

IMPORT Files, StdLog;

END CreateFile.

=={{header|Crystal}}==

Dir.mkdir "docs"

File.write "/output.txt", ""

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

=={{header|DCL}}==

open/write output_file [000000]output.txt

create/directory [.docs]

=={{header|Delphi}}==

These functions illustrate two methods for creating text files in Delphi: standard text file I/O and filestreams.

program createFile;

=={{header|E}}==

<file:docs>.mkdir(null)

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

=={{header|EchoLisp}}==

;; The file system is the browser local storage

;; It is divided into named stores (directories)

(local-stores 'root) → ("root" "root/docs")

(local-stores 'user) → ("user" "user/docs")

=={{header|Elena}}==

ELENA 4.x :

public program()

Directory.assign("\docs").create();

=={{header|Elixir}}==

File.open("/output.txt", [:write])

File.mkdir!("docs")

=={{header|Emacs Lisp}}==

(make-directory "docs")

(make-empty-file "/output.txt")

=={{header|Erlang}}==

"/" is documented as working on Windows.

-module(new_file).

-export([main/0]).

ok = file:write_file( filename:join(["/", "output.txt"]), <<>> ),

ok = file:make_dir( filename:join(["/", "docs"]) ).

=={{header|ERRE}}==

Filenames are in 8+3 DOS format: without drive and directory info, refer to the same directory as the ERRE program is running from; full pathnames can include drive name and directory.

You must use PC.LIB for managing directories.

PROGRAM FILE_TEST

END PROGRAM

=={{header|Euphoria}}==

-- In the current working directory

system("mkdir \\docs",2)

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

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

[<EntryPoint>]

ignore (File.Create(Path.Combine(path, fileName)))

ignore (Directory.CreateDirectory(Path.Combine(path, dirName)))

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

Don't know a way of creating directories in Fortran

#Edit: Use system commands to create directories

PROGRAM CREATION

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

END PROGRAM

=={{header|FreeBASIC}}==

' create empty file and sub-directory in current directory

Print "Press any key to quit"

=={{header|friendly interactive shell}}==

{{trans|UNIX Shell}}

=={{header|FunL}}==

{{trans|Scala}}

File( 'output.txt' ).createNewFile()

File( File.separator + 'output.txt' ).createNewFile()

File( 'docs' ).mkdir()

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=abe59d5d62a4d01817638115e75e7e29 Click this link to run this code]'''

Dim byCount As Byte

Dim sToSave As String

Print File.Load(User.Home &/ "TestFile")

Output:

<pre>

=={{header|Go}}==

import (

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

create("output.txt")

create("docs/")

create("/output.txt")

create("/docs/")

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

{{works with|Node.js}}

function fct(err) {

fs.mkdir("docs", fct);

=={{header|JCL}}==

// EXEC PGM=IEFBR14

//* CREATE EMPTY FILE NAMED "OUTPUT.TXT" (file names upper case only)

//* CREATE DIRECTORY (PARTITIONED DATA SET) NAMED "DOCS"

//ANYNAME DD UNIT=SYSDA,SPACE=(TRK,(1,1)),DSN=DOCS,DISP=(,CATLG)

=={{header|Julia}}==

touch("output.txt")

catch e

warn(e)

=={{header|K}}==

Directory creation is OS-dependent

{{Works with|Kona}}

"/output.txt" 1: ""

\ mkdir docs

=={{header|Kotlin}}==

to create files in the root */

println("$path already exists")

}

{{out}}

=={{header|Lasso}}==

local(f) = file

handle => { #f->close }

// create directory in root file system (requires permissions at user OS level)

local(d = dir('//docs'))

=={{header|LFE}}==

(: file write_file '"output.txt" '"Some data")

(: file make_dir '"docs")

(: file write_file '"/output.txt" '"Some data")

(: file make_dir '"/docs")

=={{header|Liberty BASIC}}==

<br>

Full pathnames including drive name and directory can be used- back-slash separated.

nomainwin

end

=={{header|Lingo}}==

Create an empty file in cwd:

fp = xtra("fileIO").new()

Create empty file in root of current volume:

pd = the last char of _movie.path -- "\" for win, ":" for mac

_player.itemDelimiter = pd

vol = _movie.path.item[1]

fp = xtra("fileIO").new()

Creating an empty directory requires a 3rd party xtra, but there are various free xtras that allow this. Here as example usage of Shell xtra:

shell_cmd("mkdir \Docs") -- win

=={{header|Little}}==

We are going to use /tmp instead the root.

FILE f;

unless (exists(path)) {

create_file("/tmp/output.txt");

create_dir("docs");

=={{header|Lua}}==

==== Create File ====

==== Create Directory ====

This solution sends the command to the OS shell.

A more portable solution requires a library such as LuaFileSystem.

lfs.mkdir("docs")

=={{header|M2000 Interpreter}}==

Module MakeDirAndFile {

Def WorkingDir$, RootDir$

}

MakeDirAndFile

=={{header|Maple}}==

FileTools:-Text:-WriteFile("output.txt", ""); # make empty file in current dir

FileTools:-MakeDirectory("docs"); # make empty dir in current dir

FileTools:-Text:-WriteFile("/output.txt", ""); # make empty file in root dir

FileTools:-MakeDirectory("/docs"); # make empty dir in root dir

=={{header|Mathematica}} / {{header|Wolfram Language}}==

SetDirectory@NotebookDirectory[];

t = OpenWrite["output.txt"]

(*"left<>right" is shorthand for "StringJoin[left,right]"*)

=={{header|MATLAB}} / {{header|Octave}}==

fid = fopen('/output.txt','w'); fclose(fid);

mkdir('docs');

=={{header|Maxima}}==

close(f);

/* Maxima has no function to create directories, but one can use the underlying Lisp system */

=={{header|MAXScript}}==

f = createFile "output.txt"

close f

f = createFile "\output.txt"

close f

=={{header|Mercury}}==

:- interface.

io.write_string(Stderr, io.error_message(Error), !IO),

io.nl(Stderr, !IO),

=={{header|Mirah}}==

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

File.new('docs').mkdir()

File.new("docs#{File.separator}output.txt").createNewFile()

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

IMPORT FS, File, OSError, IO, Stdio;

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

END;

=={{header|Nanoquery}}==

f = new(File)

f.create("/output.txt")

f.createDir("/docs")

=={{header|Nemerle}}==

using System.IO;

// no Exception for directory creation

}

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

return

=={{header|Nim}}==

open("output.txt", fmWrite).close()

open(DirSep & "output.txt", fmWrite).close()

{{trans|Python}}

const directories = ["/", "./"]

for directory in directories:

open(directory & "output.txt", fmWrite).close()

=={{header|Objeck}}==

use IO;

}

}

=={{header|Objective-C}}==

[fm createFileAtPath:@"output.txt" contents:[NSData data] attributes:nil];

[fm createDirectoryAtPath:@"docs" attributes:nil];

// OS X 10.5+

=={{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|PARI/GP}}==

Creating an empty file in GP requires <code>write1</code> rather than <code>write</code> to avoid the automatic newline.

GP cannot, itself, create directories; for that, you would need PARI (where the solution would follow those in [[#C|C]]) or <code>system</code>:

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

'''For comparison with Raku'''

mkdir "${prefix}docs";

open my $FH, '>', "${prefix}docs/output.txt";

Cleanup

=={{header|Phix}}==

Copy of [[Create_a_file#Euphoria|Euphoria]], modified to display a warning when it cannot create a file in the system root (as such is typically banned on more recent operating systems)

-- In the current working directory

else

close(fn)

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

changedirectory docs

=={{header|PureBasic}}==

CreateDirectory("docs")

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

=={{header|Python}}==

for directory in ['/', './']:

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

(display-to-file "" "output.txt")

(make-directory "docs")

(display-to-file "" "/output.txt")

=={{header|Raku}}==

(formerly Perl 6)

for '.', '' -> $prefix {

mkdir "$prefix/docs";

open "$prefix/output.txt", :w;

}

=={{header|Raven}}==

str 'output.txt' write

str '/output.txt' write

'docs' mkdir