Create a file: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
(Create a file en Yabasic) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(21 intermediate revisions by 16 users not shown) | |||
Line 6:
=={{header|11l}}==
{{trans|Python}}
<
File(directory‘output.txt’, ‘w’) // create /output.txt, then ./output.txt
fs:create_dir(directory‘docs’) // create directory /docs, then ./docs</
=={{header|4DOS Batch}}==
<
mkdir docs
echos > \output.txt
mkdir \docs</
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program createDirFic64.s */
Line 130:
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|Action!}}==
The attached result has been obtained under DOS 2.5.
<
CHAR ARRAY line(255)
BYTE dev=[1]
Line 169:
PrintF("Dir ""%S""%E",filter)
Dir(filter)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Create_a_file.png Screenshot from Atari 8-bit computer]
Line 191:
* 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;
Line 207:
Create_Directory("/docs");
end File_Creation;</
=={{header|Aikido}}==
<
var sout = openout ("output.txt") // in current dir
sout.close()
Line 220:
mkdir ("/docs")
</syntaxhighlight>
=={{header|Aime}}==
<
void
mkdir(text p)
Line 259:
return 0;
}</
=={{header|ALGOL 68}}==
Line 268:
{{works with|ALGOL 68|Standard - no extensions to language used}}
It may be best to to use an operating system provided library.
<
INT errno;
Line 305:
errno := mkpage("input.txt",2);
)</
=={{header|APL}}==
<
'\output.txt' ⎕ncreate ¯1+⌊/0,⎕nnums
⎕mkdir 'Docs'
⎕mkdir '\Docs'</
=={{header|AppleScript}}==
Line 317:
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).
<syntaxhighlight lang="applescript
Create a zero-byte text file in the frontmost (open) Finder window.
<
close (open for access wd & "output.txt")</
Create a new folder (directory) in the frontmost (open) Finder window.
<syntaxhighlight lang="applescript
--[[User:Apl.way|Apl.way]] 21:20, 9 June 2010 (UTC)
Line 338:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
Line 467:
</syntaxhighlight>
=={{header|Arturo}}==
<
docs: "docs"
Line 478:
write join.path ["/" output] ""
write.directory join.path ["/" docs] ø</
=={{header|AutoHotkey}}==
<
FileCreateDir, docs
FileAppend,,c:\output.txt
FileCreateDir, c:\docs</
=={{header|AWK}}==
<
printf "" > "output.txt"
close("output.txt")
Line 494:
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
CLOSE</
==={{header|Applesoft BASIC}}===
There are disk volumes, but no folders in DOS 3.3.
<syntaxhighlight lang="gwbasic"> 0 D$ = CHR$ (4): PRINT D$"OPEN OUTPUT.TXT": PRINT D$"CLOSE"</syntaxhighlight>
==={{header|BaCon}}===
<
TRAP LOCAL
Line 529 ⟶ 532:
LABEL report2
PRINT ERR$(ERROR)</
{{out}}
Line 552 ⟶ 555:
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"
Line 559 ⟶ 562:
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
</syntaxhighlight>
<pre>
Line 580 ⟶ 583:
=={{header|Batch File}}==
<
copy nul \output.txt</
<
md \docs</
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
CLOSE #OPENOUT("\output.txt")
*MKDIR docs
*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.
<syntaxhighlight lang="blue">global _start
: syscall ( num:eax -- result:eax ) syscall ;
: exit ( status:edi -- noret ) 60 syscall ;
: bye ( -- noret ) 0 exit ;
: die ( err:eax -- noret ) neg exit ;
: unwrap ( result:eax -- value:eax ) dup 0 cmp ' die xl ;
: ordie ( result -- ) unwrap drop ;
: open ( pathname:edi flags:esi mode:edx -- fd:eax ) 2 syscall unwrap ;
: close ( fd:edi -- ) 3 syscall ordie ;
: mkdir ( pathname:edi mode:esi -- ) 83 syscall ordie ;
00001 const for-writing
00100 const create
01000 const truncate
: create-file ( pathname -- )
create for-writing or truncate or
0640 open close ;
: make-directory ( pathname -- ) 0750 mkdir ;
: create-output-file ( -- ) s" output.txt" drop create-file ;
: make-docs-directory ( -- ) s" docs" drop make-directory ;
: _start ( -- noret )
create-output-file
make-docs-directory
bye
;</syntaxhighlight>
=={{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>.
<syntaxhighlight lang="bqn">"output.txt" •file.Chars ""
"/output.txt" •file.Chars ""
•file.CreateDir "docs"
•file.CreateDir "/docs"</syntaxhighlight>
=={{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:
<syntaxhighlight lang
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() {
Line 614 ⟶ 664:
return 0;
}</
=== POSIX ===
{{works with|POSIX}}
<
#include <unistd.h>
#include <fcntl.h>
Line 632 ⟶ 682:
return 0;
}</
(for creation in the filesystem root, replace the filenames by "/output.txt" and "/docs")
Line 640 ⟶ 690:
First, a solution with the C runtime functions <code>_creat</code> and <code>_mkdir</code>.
<
#include <io.h>
#include <sys/stat.h>
Line 670 ⟶ 720:
return 0;
}</
Another solution with the kernel32 API functions <code>CreateFile</code> and <code>CreateDirectory</code>.
<
#include <stdio.h>
Line 705 ⟶ 755:
return 0;
}</
=== OS/2 ===
Line 711 ⟶ 761:
Using the OS/2 API functions <code>DosOpen</code> and <code>DosMkDir</code>.
<
int main(void) {
Line 749 ⟶ 799:
return 0;
}</
=={{header|C sharp|C#}}==
<
using System.IO;
Line 764 ⟶ 814:
Directory.CreateDirectory(@"\docs");
}
}</
=={{header|C++}}==
Uses some Microsoft library:
<
#include <fstream>
Line 781 ⟶ 831:
return 0;
}</
A cross-platform solution using C++17
<
#include <fstream>
Line 798 ⟶ 848:
fs::create_directory("docs");
fs::create_directory("/docs");
}</
=={{header|ChucK}}==
This creates a file in root:
<syntaxhighlight lang="c">
FileIO text;
text.open("output.txt", FileIO.WRITE);
</syntaxhighlight>
=={{header|Clojure}}==
<
(.createNewFile (new File "output.txt"))
(.mkdir (new File "docs"))
(.createNewFile (File. (str (File/separator) "output.txt")))
(.mkdir (File. (str (File/separator) "docs")))</
=={{header|COBOL}}==
{{works with|GnuCOBOL}} and other compilers with the system call extensions
<
program-id. create-a-file.
Line 856 ⟶ 906:
.
end program create-a-file.</
{{out}}
<pre>
Line 874 ⟶ 924:
=={{header|Common Lisp}}==
Lisp provides open and close commands for I/O with files<
(close stream))</
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")))))
(mapcar #'ensure-directories-exist paths))</
So creating a file called ''output.txt'' with an absolute path in the root directory becomes:
<
(stream
(make-pathname :directory '(:absolute "") :name "output.txt")
:direction :output))</
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;
Line 914 ⟶ 964:
END CreateFile.
</syntaxhighlight>
=={{header|Crystal}}==
<
Dir.mkdir "docs"
File.write "/output.txt", ""
Dir.mkdir "/docs"</
=={{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 ;
Line 971 ⟶ 1,021:
writefln("== test: File & Dir Creation ==") ;
testCreate("output.txt", "docs") ;
}</
=={{header|Dc}}==
<
=={{header|DCL}}==
<
open/write output_file [000000]output.txt
create/directory [.docs]
create/directory [000000.docs]</
=={{header|Delphi}}==
Line 986 ⟶ 1,036:
These functions illustrate two methods for creating text files in Delphi: standard text file I/O and filestreams.
<syntaxhighlight lang="delphi">
program createFile;
Line 1,089 ⟶ 1,139:
</syntaxhighlight>
=={{header|E}}==
<
<file:docs>.mkdir(null)
<file:///output.txt>.setBytes([])
<file:///docs>.mkdir(null)</
=={{header|EchoLisp}}==
<
;; The file system is the browser local storage
;; It is divided into named stores (directories)
Line 1,115 ⟶ 1,165:
(local-stores 'root) → ("root" "root/docs")
(local-stores 'user) → ("user" "user/docs")
</syntaxhighlight>
=={{header|Elena}}==
ELENA 4.x :
<
public program()
Line 1,130 ⟶ 1,180:
Directory.assign("\docs").create();
}</
=={{header|Elixir}}==
<
File.open("/output.txt", [:write])
File.mkdir!("docs")
File.mkdir!("/docs")</
=={{header|Emacs Lisp}}==
<
(make-directory "docs")
(make-empty-file "/output.txt")
(make-directory "/docs")</
=={{header|Erlang}}==
"/" is documented as working on Windows.
<
-module(new_file).
-export([main/0]).
Line 1,156 ⟶ 1,206:
ok = file:write_file( filename:join(["/", "output.txt"]), <<>> ),
ok = file:make_dir( filename:join(["/", "docs"]) ).
</syntaxhighlight>
=={{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.
<syntaxhighlight lang="erre">
PROGRAM FILE_TEST
Line 1,176 ⟶ 1,226:
END PROGRAM
</syntaxhighlight>
=={{header|Euphoria}}==
<
-- In the current working directory
Line 1,189 ⟶ 1,239:
system("mkdir \\docs",2)
fn = open("\\output.txt","w")
close(fn)</
=={{header|F_Sharp|F#}}==
<
[<EntryPoint>]
Line 1,201 ⟶ 1,251:
ignore (File.Create(Path.Combine(path, fileName)))
ignore (Directory.CreateDirectory(Path.Combine(path, dirName)))
0</
=={{header|Factor}}==
<
"output.txt" "/output.txt" [ touch-file ] bi@
"docs" "/docs" [ make-directory ] bi@</
=={{header|Fancy}}==
<
# create '/docs', then './docs'
Directory create: (dir ++ "docs")
Line 1,217 ⟶ 1,267:
f writeln: "hello, world!"
}
}</
=={{header|Forth}}==
There is no means to create directories in ANS Forth.
<
s" /output.txt" w/o create-file throw ( fileid) drop</
=={{header|Fortran}}==
Line 1,228 ⟶ 1,278:
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
Line 1,241 ⟶ 1,291:
END PROGRAM
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
' create empty file and sub-directory in current directory
Line 1,258 ⟶ 1,308:
Print "Press any key to quit"
Sleep</
=={{header|friendly interactive shell}}==
{{trans|UNIX Shell}}
<
mkdir {/,}docs # create both /docs and docs</
=={{header|FunL}}==
{{trans|Scala}}
<
File( 'output.txt' ).createNewFile()
File( File.separator + 'output.txt' ).createNewFile()
File( 'docs' ).mkdir()
File( File.separator + 'docs' ).mkdir()</
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
CFURLRef url
url = fn URLFileURLWithPath( fn StringByExpandingTildeInPath(@"~/Desktop/output.txt") )
if (fn FileManagerCreateFileAtURL( url, NULL, NULL ) )
NSLog( @"File \"output.txt\" created." )
else
NSLog( @"Unable to create file \"output.txt\"." )
end if
url = fn URLFileURLWithPath( fn StringByExpandingTildeInPath(@"~/Desktop/docs") )
if (fn FileManagerCreateDirectoryAtURL( url, YES, NULL ) )
NSLog( @"Directory \"docs\" created." )
else
NSLog( @"Unabled to create directory \"docs\"." )
end if
HandleEvents
</syntaxhighlight>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=abe59d5d62a4d01817638115e75e7e29 Click this link to run this code]'''
<
Dim byCount As Byte
Dim sToSave As String
Line 1,287 ⟶ 1,360:
Print File.Load(User.Home &/ "TestFile")
End</
Output:
<pre>
Line 1,299 ⟶ 1,372:
=={{header|Go}}==
<
import (
Line 1,330 ⟶ 1,403:
createDir("docs")
createDir("/docs")
}</
=={{header|Groovy}}==
<
new File(File.separator + "output.txt").createNewFile()
new File("docs").mkdir()
new File(File.separator + "docs").mkdir()</
=={{header|Haskell}}==
<
createFile name = writeFile name ""
Line 1,348 ⟶ 1,421:
createDirectory "docs"
createFile "/output.txt"
createDirectory "/docs"</
=={{header|HicEst}}==
<
OPEN(FILE="output.txt", "NEW") ! in current directory
SYSTEM(DIR="C:\docs") ! create C:\docs if not existent, make it current
OPEN(FILE="output.txt", "NEW") ! in C:\docs </
=={{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.
Line 1,377 ⟶ 1,450:
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].
<
1!:5 <'/docs' NB. create a directory</
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'
Line 1,387 ⟶ 1,460:
require 'general/dirutils' NB. addon package
NB. create two directories: /docs and docs:
dircreate '/docs' ; '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.)
Line 1,398 ⟶ 1,471:
=={{header|Java}}==
<syntaxhighlight lang
import java.io.File;
import java.io.IOException;
</syntaxhighlight>
<syntaxhighlight lang="java">
void create() throws IOException {
File file = new File("output.txt");
/* create an empty file */
file.createNewFile();
File directory = new File("docs/");
/* create all parent directories */
directory.mkdirs();
File rootDirectory = new File("/docs/");
rootDirectory.mkdirs();
}
</syntaxhighlight>
<br />
An alternate implementation
<syntaxhighlight lang="java">import java.io.*;
public class CreateFileTest {
public static void main(String args[]) {
Line 1,410 ⟶ 1,501:
}
}
}</
=={{header|JavaScript}}==
{{works with|Node.js}}
<
function fct(err) {
Line 1,424 ⟶ 1,515:
fs.mkdir("docs", fct);
fs.mkdir("/docs", fct);</
=={{header|JCL}}==
<syntaxhighlight lang="jcl">
// EXEC PGM=IEFBR14
//* CREATE EMPTY FILE NAMED "OUTPUT.TXT" (file names upper case only)
Line 1,433 ⟶ 1,524:
//* CREATE DIRECTORY (PARTITIONED DATA SET) NAMED "DOCS"
//ANYNAME DD UNIT=SYSDA,SPACE=(TRK,(1,1)),DSN=DOCS,DISP=(,CATLG)
</syntaxhighlight>
=={{header|Julia}}==
<
touch("output.txt")
Line 1,447 ⟶ 1,538:
catch e
warn(e)
end</
=={{header|K}}==
Directory creation is OS-dependent
{{Works with|Kona}}
<
"/output.txt" 1: ""
\ mkdir docs
\ mkdir /docs</
=={{header|Kotlin}}==
<
to create files in the root */
Line 1,481 ⟶ 1,572:
println("$path already exists")
}
}</
{{out}}
Line 1,501 ⟶ 1,592:
=={{header|LabVIEW}}==
{{VI solution|LabVIEW_Create_a_file.png}}
=={{header|Lang}}==
{{libheader|lang-io-module}}
<syntaxhighlight lang="lang">
# Load the IO module
# Replace "<pathToIO.lm>" with the location where the io.lm Lang module was installed to without "<" and ">"
ln.loadModule(<pathToIO.lm>)
$file1 = [[io]]::fp.openFile(output.txt)
[[io]]::fp.createFile($file1)
[[io]]::fp.closeFile($file1)
$file2 = [[io]]::fp.openFile(/output.txt)
[[io]]::fp.createFile($file2)
[[io]]::fp.closeFile($file2)
$dir1 = [[io]]::fp.openFile(docs)
[[io]]::fp.makeDirectory($dir1)
[[io]]::fp.closeFile($dir1)
$dir2 = [[io]]::fp.openFile(/docs)
[[io]]::fp.makeDirectory($dir2)
[[io]]::fp.closeFile($dir2)
</syntaxhighlight>
=={{header|Lasso}}==
<
local(f) = file
handle => { #f->close }
Line 1,519 ⟶ 1,634:
// create directory in root file system (requires permissions at user OS level)
local(d = dir('//docs'))
#d->create</
=={{header|LFE}}==
<
(: file write_file '"output.txt" '"Some data")
(: file make_dir '"docs")
(: file write_file '"/output.txt" '"Some data")
(: file make_dir '"/docs")
</syntaxhighlight>
=={{header|Liberty BASIC}}==
Line 1,534 ⟶ 1,649:
<br>
Full pathnames including drive name and directory can be used- back-slash separated.
<syntaxhighlight lang="lb">
nomainwin
Line 1,547 ⟶ 1,662:
end
</syntaxhighlight>
=={{header|Lingo}}==
Line 1,553 ⟶ 1,668:
Create an empty file in cwd:
<
fp = xtra("fileIO").new()
fp.createFile("output.txt")</
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()
fp.createFile(vol&pd&"output.txt")</
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
shell_cmd("mkdir /Docs") -- mac</
=={{header|Little}}==
We are going to use /tmp instead the root.
<
FILE f;
unless (exists(path)) {
Line 1,604 ⟶ 1,719:
create_file("/tmp/output.txt");
create_dir("docs");
create_dir("/tmp/docs");</
=={{header|Lua}}==
Line 1,611 ⟶ 1,726:
==== Create File ====
<
io.open("\\output.txt", "w"):close()</
==== Create Directory ====
This solution sends the command to the OS shell.
<
os.execute("mkdir \\docs")</
A more portable solution requires a library such as LuaFileSystem.
<
lfs.mkdir("docs")
lfs.mkdir("/docs")</
=={{header|M2000 Interpreter}}==
Line 1,643 ⟶ 1,758:
Work nice in Ubuntu using Wine.
In Windows 10 we have to open M2000 environment (m2000.exe) with elevated privileges to have write access directly in root directory (so without it, we get error from task(RootDir$))
<syntaxhighlight lang="m2000 interpreter">
Module MakeDirAndFile {
Def WorkingDir$, RootDir$
Line 1,666 ⟶ 1,781:
}
MakeDirAndFile
</syntaxhighlight>
=={{header|M6809 Assembler}}==
<syntaxhighlight lang="M6809 Assembler">
nam create_file
ttl M6809 Program to create a file and a directory
*
* M6809 Assembler running under the OS-9 Operating System
* built with: asm cf.a L O=cf #32k
*
ifp1
use /DD/defs/os9.d
endc
*
mod PRGSIZ,PRGNAM,TYPE,REVS,START,SIZE
PRGNAM fcs /cf/
TYPE set Prgrm+Objct
REVS set ReEnt+1
HEREF fcs './output.txt'
fcb $0D
ROOTF fcs '/dd/output.txt'
fcb $0D
HERED fcs './docs'
fcb $0D
ROOTD fcs '/dd/docs'
fcb $0D
rmb 250
rmb 200
SIZE equ .
*
START equ *
leax HEREF,pcr
lda #UPDAT.
ldb #READ.+WRITE.+PREAD.+PWRIT.
os9 I$Create
leax ROOTF,pcr
lda #UPDAT.
ldb #READ.+WRITE.+PREAD.+PWRIT.
os9 I$Create
leax HERED,pcr
lda #UPDAT.
ldb #READ.+WRITE.+PREAD.+PWRIT.
os9 I$MakDir
leax ROOTD,pcr
lda #UPDAT.
ldb #READ.+WRITE.+PREAD.+PWRIT.
os9 I$MakDir
clrb
os9 F$Exit
emod
PRGSIZ equ *
END
</syntaxhighlight>
=={{header|Maple}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">
SetDirectory@NotebookDirectory[];
t = OpenWrite["output.txt"]
Line 1,690 ⟶ 1,859:
(*"left<>right" is shorthand for "StringJoin[left,right]"*)
</syntaxhighlight>
=={{header|MATLAB}} / {{header|Octave}}==
<
fid = fopen('/output.txt','w'); fclose(fid);
mkdir('docs');
mkdir('/docs');</
=={{header|Maxima}}==
<
close(f);
Line 1,707 ⟶ 1,876:
/* Maxima has no function to create directories, but one can use the underlying Lisp system */
:lisp (mapcar #'ensure-directories-exist '("docs/" "/docs/"))</
=={{header|MAXScript}}==
<
f = createFile "output.txt"
close f
Line 1,717 ⟶ 1,886:
f = createFile "\output.txt"
close f
makeDir ("c:\docs")</
=={{header|Mercury}}==
<
:- interface.
Line 1,765 ⟶ 1,934:
io.write_string(Stderr, io.error_message(Error), !IO),
io.nl(Stderr, !IO),
io.set_exit_status(1, !IO).</
=={{header|Mirah}}==
<
File.new('output.txt').createNewFile()
File.new('docs').mkdir()
File.new("docs#{File.separator}output.txt").createNewFile()
</syntaxhighlight>
=={{header|Modula-3}}==
<
IMPORT FS, File, OSError, IO, Stdio;
Line 1,793 ⟶ 1,962:
| OSError.E => IO.Put("Error creating file or directory.\n", Stdio.stderr);
END;
END FileCreation.</
=={{header|Nanoquery}}==
<
f = new(File)
Line 1,805 ⟶ 1,974:
f.create("/output.txt")
f.createDir("/docs")
</syntaxhighlight>
=={{header|Nemerle}}==
<
using System.IO;
Line 1,830 ⟶ 1,999:
// no Exception for directory creation
}
}</
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 1,858 ⟶ 2,027:
return
</syntaxhighlight>
=={{header|Nim}}==
<
open("output.txt", fmWrite).close()
Line 1,867 ⟶ 2,036:
open(DirSep & "output.txt", fmWrite).close()
createDir(DirSep & "docs")</
{{trans|Python}}
<
const directories = ["/", "./"]
for directory in directories:
open(directory & "output.txt", fmWrite).close()
createDir(directory & "docs")</
=={{header|Objeck}}==
<
use IO;
Line 1,894 ⟶ 2,063:
}
}
</syntaxhighlight>
=={{header|Objective-C}}==
<
[fm createFileAtPath:@"output.txt" contents:[NSData data] attributes:nil];
Line 1,904 ⟶ 2,073:
[fm createDirectoryAtPath:@"docs" attributes:nil];
// OS X 10.5+
[fm createDirectoryAtPath:@"docs" withIntermediateDirectories:NO attributes:nil error:NULL];</
=={{header|OCaml}}==
<
close_out oc;;
- : unit = ()
# Unix.mkdir "docs" 0o750 ;; (* rights 0o750 for rwxr-x--- *)
- : unit = ()</
(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']}
end</
=={{header|PARI/GP}}==
Creating an empty file in GP requires <code>write1</code> rather than <code>write</code> to avoid the automatic newline.
<
write1("/0.txt","")</
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}}==
Line 1,937 ⟶ 2,106:
The Pascal & Delphi Standard Libraries support all of this functionality.
<
program in out;
Line 1,955 ⟶ 2,124:
end;
</syntaxhighlight>
=={{header|Perl}}==
<
{ # here
open my $fh, '>', 'output.txt';
Line 1,966 ⟶ 2,135:
open my $fh, '>', catfile rootdir, 'output.txt';
mkdir catfile rootdir, 'docs';
};</
'''Without Perl Modules'''
Current directory
<
perl -e 'mkdir docs'</
Root directory
<
perl -e 'mkdir "/docs"'</
'''For comparison with Raku'''
<
mkdir "${prefix}docs";
open my $FH, '>', "${prefix}docs/output.txt";
}</
Cleanup
<
rmdir $_ for qw(/docs ./docs);</
=={{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)
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span>
<span style="color: #000080;font-style:italic;">-- In the current working directory</span>
<span style="color: #7060A8;">system</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"mkdir docs"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"output.txt"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"w"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">-- In the filesystem root</span>
<span style="color: #7060A8;">system</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"mkdir \\docs"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"\\output.txt"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"w"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">fn</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"unable to create \\output.txt\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">else</span>
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<!--</syntaxhighlight>-->
=={{header|Phixmonti}}==
<syntaxhighlight lang="Phixmonti">"foo.bar" "w" fopen fclose</syntaxhighlight>
=={{header|PHP}}==
<
touch('output.txt');
mkdir('docs');
touch('/output.txt');
mkdir('/docs');
?></
=={{header|PicoLisp}}==
<
(call 'mkdir "docs") # Call external
(out "/output.txt")
(call 'mkdir "/docs")</
=={{header|Pike}}==
<
int main(){
write_file("input.txt","",0100);
write_file("/input.txt","",0100);
}</
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
open file (output) title ('/OUTPUT.TXT,type(text),recsize(100)' );
close file (output);
</syntaxhighlight>
=={{header|Plain English}}==
When I tested this program, it did not create "output.txt" in the filesystem root.
<syntaxhighlight lang="text">
To run:
Start up.
\ In the current working directory
Create ".\output.txt" in the file system.
Create ".\docs\" in the file system.
\ In the filesystem root
Create "C:\output.txt" in the file system.
Create "C:\docs\" in the file system.
Shut down.
</syntaxhighlight>
=={{header|PowerShell}}==
<
New-Item \output.txt -ItemType File
New-Item docs -ItemType Directory
New-Item \docs -ItemType Directory</
=={{header|ProDOS}}==
<
changedirectory docs
makenewfile output.txt</
=={{header|PureBasic}}==
<
CreateDirectory("docs")
CreateFile(0,"/output.txt"):CloseFile(0)
CreateDirectory("/docs")</
=={{header|Python}}==
<
for directory in ['/', './']:
open(directory + 'output.txt', 'w').close() # create /output.txt, then ./output.txt
os.mkdir(directory + 'docs') # create directory /docs, then ./docs</
{{works with|Python|2.5}}
Exception-safe way to create file:
<
import os
def create(directory):
Line 2,068 ⟶ 2,256:
create(".") # current directory
create("/") # root directory</
=={{header|R}}==
<
close(f)
Line 2,080 ⟶ 2,268:
success <- dir.create("docs")
success <- dir.create("/docs")</
=={{header|Racket}}==
<
(display-to-file "" "output.txt")
(make-directory "docs")
(display-to-file "" "/output.txt")
(make-directory "/docs")</
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>
for '.', '' -> $prefix {
mkdir "$prefix/docs";
open "$prefix/output.txt", :w;
}
</syntaxhighlight>
=={{header|Raven}}==
<
str 'output.txt' write
str '/output.txt' write
'docs' mkdir
'/docs' mkdir</
=={{header|REBOL}}==
<
write %output.txt ""
Line 2,118 ⟶ 2,306:
write %/output.txt ""
make-dir %/docs/
</syntaxhighlight>
=={{header|Retro}}==
There are no facilities in Retro to create directories.
<syntaxhighlight lang="retro">
'output.txt file:W file:open file:close
'/output.txt file:W file:open file:close</
=={{header|REXX}}==
This REXX version works under Microsoft Windows (any version).
<
do 2 /*perform three statements twice.*/
'COPY NUL output.txt' /*copy a "null" (empty) file. */
Line 2,135 ⟶ 2,323:
'CD \' /*change currect dir to the root.*/
end /*2*/ /*now, go and perform them again.*/
/*stick a fork in it, we're done.*/</
=={{header|Ring}}==
<
system("mkdir C:\Ring\docs")
fopen("C:\Ring\docs\output.txt", "w+")
system("mkdir docs")
fopen("output.txt", "w+")
</syntaxhighlight>
=={{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|Run BASIC}}==
<
close #f
Line 2,159 ⟶ 2,347:
open "f:\doc\output.txt" for output as #f
close #f</
=={{header|Rust}}==
<
use std::fs::{DirBuilder, File};
use std::path::Path;
Line 2,187 ⟶ 2,375:
let _ = writeln!(&mut io::stderr(), "Error: {}", error);
process::exit(code)
}</
=={{header|S-BASIC}}==
CP/M (the only operating system supported by S-BASIC) does not have named directories or a
tree-structured file system. The closest thing to a "root" directory would be user area 0 on
drive A:, which on a stock system will be the logged in directory on a cold boot. The "call"
statement, which normally serves to invoke an assembly language routine, is here used to
call upon the BDOS to switch to the desired directory.
<syntaxhighlight lang="basic">
rem -- Set the logged drive ('A' to 'P')
procedure setdrive (drive = char)
var hl, de, bc, a_psw = integer
rem -- ensure drive letter is upper case
if drive >= 'a' then drive = drive - 32
hl = 0
de = drive - 65
bc = 0EH rem BDOS set drive function
a_psw = 0
rem - call BDOS with drive number in DE
call (5H,hl,de,bc,a_psw)
end
rem -- Set the CP/M user area (0 to 15)
procedure setuser (user = integer)
var hl, bc, a_psw = integer
hl = 0
bc = 20H rem BDOS set user function
a_psw = 0
rem - call BDOS with user number in DE
call (5H,hl,user,bc,a_psw)
end
comment
create empty file "output.txt" in current directory and in
startup directory (drive A:, user 0)
end
create "OUTPUT.TXT"
setdrive 'A'
setuser 0
create "OUTPUT.TXT"
end
</syntaxhighlight>
=={{header|Scala}}==
{{libheader|Scala}}<
object CreateFile extends App {
Line 2,201 ⟶ 2,437:
try { new File(s"${File.separator}docs").mkdir() }
catch { case e: Exception => println(s"Exception caught: $e with creating directory ${File.separator}docs") }
}</
=={{header|Scheme}}==
<
(open-output-file "/output.txt")</
Results:
> file output.txt
Line 2,220 ⟶ 2,456:
when it is started by a normal user.
<
include "osfiles.s7i";
Line 2,233 ⟶ 2,469:
close(aFile);
mkdir("/docs");
end func;</
Under Windows each filesystem has its own root.
Line 2,239 ⟶ 2,475:
=={{header|SenseTalk}}==
<
put "" into file "docs/output.txt"
set the folder to "/"
put empty into file "/docs/output.txt"</
Or without defining a working directory:
<
put "" into file "/docs/output.txt"</
Or using the Create command:
<
create folder "docs"</
=={{header|Sidef}}==
<
%f'output.txt' -> create;
%d'docs' -> create;
Line 2,257 ⟶ 2,493:
# Root dir
Dir.root + %f'output.txt' -> create;
Dir.root + %d'docs' -> create;</
=={{header|Slate}}==
File creation locally:
<
(Directory current / 'output.txt') touch.</
File creation at root:
<
(Directory root / 'output.txt') touch.</
=={{header|Slope}}==
Local:
<syntaxhighlight lang="slate">(close (file-open-write "output.txt"))
(mkdir "docs" 0755)</syntaxhighlight>
Root:
<syntaxhighlight lang="slate">(close (file-open-write "/output.txt"))
(mkdir "/docs" 0755)</syntaxhighlight>
=={{header|Smalltalk}}==
Line 2,272 ⟶ 2,518:
[[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'.
Line 2,282 ⟶ 2,528:
ws := (File name: '/output.txt') writeStream.
ws close.
Directory create: '/docs'.</
=={{header|SNOBOL4}}==
Line 2,289 ⟶ 2,535:
{{works with|CSnobol}}
<
* output(.file,1,,'output.txt'); endfile(1) ;* CSnobol
host(1,'mkdir docs')
Line 2,296 ⟶ 2,542:
* output(.file,1,,'/output.txt'); endfile(1) ;* CSnobol
host(1,'mkdir /docs')
end</
=={{header|SQL PL}}==
{{works with|Db2 LUW}} version 9.7 or higher.
With SQL PL:
<
BEGIN
DECLARE UTL_FILE_HANDLER UTL_FILE.FILE_TYPE;
Line 2,326 ⟶ 2,572:
CALL UTL_FILE.FCLOSE(UTL_FILE_HANDLER);
END @
</syntaxhighlight>
The current directory notion does not exist in Db2. However, we can consider the home directory of the instance (in this case db2inst1) as current.
For the directory under root, Db2 needs extra permissions to create a subdirectory at that level. Normally, that operation of creating a subdirectory at that level will raise an exception: "UTL_FILE.INVALID_OPERATION" SQLSTATE=58024.
Line 2,344 ⟶ 2,590:
=={{header|SQLite}}==
<
/*
*Use '/' for *nix. Use whatever your root directory is on Windows.
Line 2,353 ⟶ 2,599:
.output output.txt
.output /output.txt
</syntaxhighlight>
=={{header|Standard ML}}==
<
TextIO.closeOut out
end;
OS.FileSys.mkDir "docs";</
(for creation in the filesystem root, replace the filenames by "/output.txt" and "/docs")
Line 2,369 ⟶ 2,615:
See the [https://www.stata.com/help.cgi?file file] command in Stata documentation. Note that Stata has other ways to store files: [https://www.stata.com/help.cgi?save save] to store a dataset in .dta format, or the various [https://www.stata.com/help.cgi?export export] commands to store a dataset as CSV, Excl, SAS [http://support.sas.com/techsup/technote/ts140.pdf XPORT 5] or [http://support.sas.com/techsup/technote/ts140_2.pdf XPORT 8] or dBase format.
<
file close f
mkdir docs
Line 2,375 ⟶ 2,621:
file open f using \output.txt, write replace
file close f
mkdir \docs</
=={{header|Tcl}}==
Line 2,381 ⟶ 2,627:
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
file mkdir [file nativename /docs]</
=={{header|Toka}}==
<
" output.txt" "W" file.open file.close
" /output.txt" "W" file.open file.close
Line 2,395 ⟶ 2,641:
( Create the directories with permissions set to 777)
" docs" &777 mkdir
" /docs" &777 mkdir</
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
- create file
Line 2,404 ⟶ 2,650:
- create directory
ERROR/STOP CREATE ("docs",project,-std-)
</syntaxhighlight>
=={{header|UNIX Shell}}==
{{works with|Bourne Shell}}
<
mkdir /docs
mkdir docs # create both /docs and docs</
{{works with|bash}}
<
mkdir {/,}docs # create both /docs and docs</
{{omit from|TI-83 BASIC}} {{omit from|TI-89 BASIC}} <!-- Does not have a filesystem, just namespaced variables. -->
Line 2,421 ⟶ 2,667:
=={{header|Ursa}}==
<
f.create "output.txt"
f.createdir "docs"
Line 2,428 ⟶ 2,674:
f.create "/output.txt"
f.createdir "/docs"
</syntaxhighlight>
=={{header|VBA}}==
<
Dim FileNumber As Integer
FileNumber = FreeFile
Line 2,440 ⟶ 2,686:
Open "C:\docs\output.txt" For Output As #FreeFile
Close #FreeFile
End Sub</
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Set objFSO = CreateObject("Scripting.FileSystemObject")
Line 2,453 ⟶ 2,699:
objFSO.CreateFolder("\docs")
objFSO.CreateTextFile("\docs\output.txt")
</syntaxhighlight>
=={{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")
Line 2,463 ⟶ 2,709:
// In the root directory
File_Open("/input.txt") Ins_Char(' ') Del_Char(-1) Buf_Close()
File_Mkdir("/docs")</
=={{header|Visual Basic .NET}}==
Line 2,470 ⟶ 2,716:
{{works with|Visual Basic .NET|9.0+}}
<
IO.Directory.CreateDirectory("docs")
IO.File.Create("output.txt").Close()
Line 2,480 ⟶ 2,726:
'Root, platform independent
IO.Directory.CreateDirectory(IO.Path.DirectorySeparatorChar & "docs")
IO.File.Create(IO.Path.DirectorySeparatorChar & "output.txt").Close()</
=={{header|Visual Objects}}==
//Use Library System Library
<
DirMake(String2Psz("c:\docs"))
FCreate("c:\docs\output.txt", FC_NORMAL)
</syntaxhighlight>
{{omit from|SmileBASIC|Filesystem has no directories, only projects which cannot be manipulated by code.}}
Line 2,496 ⟶ 2,742:
Wren does not currently support the creation of directories.
<
// file is closed automatically after creation
Line 2,502 ⟶ 2,748:
// check size
System.print("%(File.size("output.txt")) bytes")</
{{out}}
Line 2,511 ⟶ 2,757:
=={{header|X86 Assembly}}==
{{works with|NASM|Linux}}
<
; syscall numbers for readability. :]
Line 2,566 ⟶ 2,812:
int 0x80 ; Make kernel call
ret
</syntaxhighlight>
=={{header|XPL0}}==
XPL0 does not currently create directories.
To create a file in the root directory, assuming you have permission,
insert a slash at the beginning, like this: /output.txt
<syntaxhighlight lang="xpl0">
int FD;
FD:= FOpen("output.txt", 1);
</syntaxhighlight>
=={{header|Yabasic}}==
<
close #1
Line 2,578 ⟶ 2,834:
open "f:\docs\output.txt" for writing as #2
close #2
end if</
=={{header|zkl}}==
Works on Unix and Windows
<
ls: cannot access docs: No such file or directory
$ zkl
Line 2,600 ⟶ 2,856:
total 0
-rw-r--r-- 1 craigd craigd 0 Oct 27 22:08 output.txt
</syntaxhighlight>
=={{header|ZX Spectrum Basic}}==
Line 2,607 ⟶ 2,863:
we create an empty file named OUTPUT of zero bytes. We can use any start address, because the file is empty. Here we write zero bytes from address 16384:
<
{{omit from|EasyLang}}
|