Some of Sunday's edits have been lost. The edits from Saturday that were reverted have been restored. Site is now hosted on prgmr.com. Thank you for your patience. This notice will be removed one week from posting. --Michael Mol 18:12, 7 March 2010 (UTC)
Create a file
From Rosetta Code
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.
[edit] Ada
Notes:
- Use Streams_IO to write 0 bytes. File creation with Ada.Text_IO does not create 0 byte files (it inserts EOL/EOF).
- The forward slash (/) notation works in Windows XP as well as Unix/Linux.
with Ada.Streams.Stream_IO, Ada.Directories;
use Ada.Streams.Stream_IO, Ada.Directories;
procedure File_Creation is
File_Handle : File_Type;
begin
Create (File_Handle, Out_File, "output.txt");
Close (File_Handle);
Create_Directory("docs");
Create (File_Handle, Out_File, "/output.txt");
Close (File_Handle);
Create_Directory("/docs");
end File_Creation;
[edit] ALGOL 68
Note: file names are Operating System dependent.
- ALGOL 68G does not support pages, and "set" procedure only has 2 arguments.
- ELLA ALGOL 68 also encounters problems with "set" page on linux.
Works with: ALGOL 68 version Standard - no extensions to language used It may be best to to use an operating system provided library.
main:(
INT errno;
PROC touch = (STRING file name)INT:
BEGIN
FILE actual file;
INT errno := open(actual file, file name, stand out channel);
IF errno NE 0 THEN GO TO stop touch FI;
close(actual file); # detach the book and keep it #
errno
EXIT
stop touch:
errno
END;
errno := touch("input.txt");
errno := touch("/input.txt");
# ALGOL 68 has no concept of directories,
however a file can have multiple pages,
the pages are identified by page number only #
PROC mkpage = (STRING file name, INT page x)INT:
BEGIN
FILE actual file;
INT errno := open(actual file, file name, stand out channel);
IF errno NE 0 THEN GO TO stop mkpage FI;
set(actual file,page x,1,1); # skip to page x, line 1, character 1 #
close(actual file); # detach the new page and keep it #
errno
EXIT
stop mkpage:
errno
END;
errno := mkpage("input.txt",2);
)
[edit] AppleScript
AppleScript itself has limited built-in File System access, but folders (directories) can be created by controlling the Mac OS Finder, and files can be created and accessed using the Standard Additions (osax) scripting addition included with AppleScript. Also, the Finder has no concept of the working directory (as it is a GUI). You can however target the frontmost Finder window that is open.
Create a zero-byte text file on the startup disk (root directory). Note: the close command is a memory allocation housekeeping command that should be performed once file access is complete.
close (open for access "output.txt")
Create a new folder (directory) on the startup disk (root directory).
tell application "Finder" to make new folder at startup disk with properties {name:"docs"}
Create a zero-byte text file in the frontmost (open) Finder window.
tell application "Finder" to set wd to target of window 1 as string
close (open for access wd & "output.txt")
Create a new folder (directory) in the frontmost (open) Finder window.
tell application "Finder" to make new folder at window 1 with properties {name:"docs"}
[edit] AutoHotkey
FileAppend,,output.txt
FileCreateDir, docs
FileAppend,,c:\output.txt
FileCreateDir, c:\docs
[edit] AWK
There's no way to create a directory, except by calling an extern program (like mkdir) to do so.
BEGIN {
printf "" > "output.txt"
# try to create the file in the root (for *nix-like systems)
printf "" > "/output.txt"
}
[edit] BASIC
OPEN "output.txt" FOR OUTPUT AS 1
CLOSE
OPEN "\output.txt" FOR OUTPUT AS 1
CLOSE
[edit] C
ISO C (directory creation not supported):
#include <stdio.h>
int main() {
FILE *fh = fopen("output.txt", "w");
fclose(fh);
return 0;
}
POSIX:
Works with: POSIX
#include <sys/stat.h>
int main() {
int fd = open("output.txt", O_WRONLY|O_CREAT|O_TRUNC, 0640); /* rights 0640 for rw-r----- */
/* or equivalently:
int fd = creat("output.txt", 0640); /* rights 0640 for rw-r----- */
close(fd);
mkdir("docs", 0750); /* rights 0750 for rwxr-x--- */
return 0;
}
(for creation in the filesystem root, replace the filenames by "/output.txt" and "/docs")
[edit] C++
Uses some Microsoft library:
#include <fstream>
#include <direct.h>
int main() {
std::fstream f( "output.txt", std::ios::out );
f.close();
f.open( "/output.txt", std::ios::out );
f.close();
_mkdir( "docs" );
_mkdir( "/docs" );
return 0;
}
[edit] C#
using System;
using System.IO;
class Program {
static void Main(string[] args) {
File.Create("output.txt");
File.Create(@"\output.txt");
Directory.CreateDirectory("docs");
Directory.CreateDirectory(@"\docs");
}
}
[edit] Clojure
(import '(java.io File))
(.createNewFile (new File "output.txt"))
(.mkdir (new File "docs"))
(.createNewFile (File. (str (File/separator) "output.txt")))
(.mkdir (File. (str (File/separator) "docs")))
[edit] Common Lisp
Lisp provides open and close commands for I/O with files(let ((stream (open "output.txt" :direction :output)))
(close stream))
but it is more common to use with-open-file which has better exception handling.
(with-open-file (stream "output.txt" :direction :output)
;; 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
(let ((paths (list (make-pathname :directory '(:relative "docs"))
(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:
(with-open-file
(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:
(mapcar #'ensure-directories-exist '(#p"docs/" #p"/docs/")))
[edit] D
For file creation, std.file.write function & std.stream.file class are used.
For dir creation, std.file.mkdir is used.
module fileio ;
import std.stdio ;
import std.path ;
import std.file ;
import std.stream ;
string[] genName(string name){
string cwd = curdir ~ sep ; // on current directory
string root = sep ; // on root
name = std.path.getBaseName(name) ;
return [cwd ~ name, root ~ name] ;
}
void Remove(string target){
if(exists(target)){
if (isfile(target))
std.file.remove(target);
else
std.file.rmdir(target) ;
}
}
void testCreate(string filename, string dirname){
// files:
foreach(fn ; genName(filename))
try{
writefln("file to be created : %s", fn) ;
std.file.write(fn, cast(void[])null) ;
writefln("\tsuccess by std.file.write") ; Remove(fn) ;
(new std.stream.File(fn, FileMode.OutNew)).close() ;
writefln("\tsuccess by std.stream") ; Remove(fn) ;
} catch(Exception e) {
writefln(e.msg) ;
}
// dirs:
foreach(dn ; genName(dirname))
try{
writefln("dir to be created : %s", dn) ;
std.file.mkdir(dn) ;
writefln("\tsuccess by std.file.mkdir") ; Remove(dn) ;
} catch(Exception e) {
writefln(e.msg) ;
}
}
void main(){
writefln("== test: File & Dir Creation ==") ;
testCreate("output.txt", "docs") ;
}
[edit] DOS Batch File
copy nul output.txt
copy nul \output.txt
md docs
md \docs
[edit] E
<file:output.txt>.setBytes([])
<file:docs>.mkdir(null)
<file:///output.txt>.setBytes([])
<file:///docs>.mkdir(null)
[edit] Factor
USE: io.directories
"output.txt" "/output.txt" [ touch-file ] bi@
"docs" "/docs" [ make-directory ] bi@
[edit] Forth
There is no means to create directories in ANS Forth.
s" output.txt" w/o create-file throw ( fileid) drop
s" /output.txt" w/o create-file throw ( fileid) drop
[edit] Fortran
Works with: Fortran version 90 and later Don't know a way of creating directories in Fortran
OPEN (UNIT=5, FILE="output.txt", STATUS="NEW") ! Current directory
CLOSE (UNIT=5)
OPEN (UNIT=5, FILE="/output.txt", STATUS="NEW") ! Root directory
CLOSE (UNIT=5)
[edit] Haskell
import System.Directory
createFile name = writeFile name ""
main = do
createFile "output.txt"
createDirectory "docs"
createFile "/output.txt"
createDirectory "/docs"
[edit] J
The conjunction !: with a scalar 1 to the left (1!:) provides the underlying cross-platform support for working with files.
'' 1!:2 <'/output.txt' NB. write an empty file
1!:5 <'/docs' NB. create a directory
However a number of libraries provide a more convenient/conventional interface to that underlying functionality.
require 'files'
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:
dircreate '/docs' ; 'docs'
[edit] Java
The line which actually creates the file is:
boolean success = new File(filename).createNewFile();
Other code is there for simplification of the main method and output.
import java.util.File;
public class CreateFileTest {
public static String createNewFile(String filename) {
try {
// Create file if it does not exist
boolean success = new File(filename).createNewFile();
if (success) {
return " did not exist and was created successfully.";
} else {
return " already exists.";
}
} catch (IOException e) {
return " could not be created.";
}
}
public static void test(String type, String filename) {
System.out.println("The following " + type + " called " + filename +
createNewFile(filename)
);
}
public static void main(String args[]) {
test("file", "output.txt");
test("file", File.seperator + "output.txt");
test("directory", "docs");
test("directory", File.seperator + "docs" + File.seperator);
}
}
[edit] JavaScript
Works with: JScript
var fso = new ActiveXObject("Scripting.FileSystemObject");
fso.CreateTextFile('output.txt').Close();
fso.CreateTextFile('c:/output.txt').Close();
fso.CreateFolder('docs');
fso.CreateFolder('c:/docs');
[edit] MAXScript
-- Here
f = createFile "output.txt"
close f
makeDir (sysInfo.currentDir + "\docs")
-- System root
f = createFile "\output.txt"
close f
makeDir ("c:\docs")
[edit] Modula-3
MODULE FileCreation EXPORTS Main;
IMPORT FS, File, OSError, IO, Stdio;
VAR file: File.T;
BEGIN
TRY
file := FS.OpenFile("output.txt");
file.close();
FS.CreateDirectory("docs");
file := FS.OpenFile("/output.txt");
file.close();
FS.CreateDirectory("/docs");
EXCEPT
| OSError.E => IO.Put("Error creating file or directory.\n", Stdio.stderr);
END;
END FileCreation.
[edit] Objective-C
NSFileManager *fm = [NSFileManager defaultManager];
[fm createFileAtPath:@"output.txt" contents:[NSData data] attributes:nil];
[fm createDirectoryAtPath:@"docs" attributes:nil];
[edit] OCaml
# let oc = open_out "output.txt" in
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")
[edit] Oz
for Dir in ["/" "./"] do
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
[edit] Perl
use File::Spec::Functions qw(catfile rootdir);
{ # here
open my $fh, '>', 'output.txt';
mkdir 'docs';
};
{ # root dir
open my $fh, '>', catfile rootdir, 'output.txt';
mkdir catfile rootdir, 'docs';
};
Without Perl Modules
Current directory
perl -e 'qx(touch output.txt)'
perl -e 'mkdir docs'
Root directory
perl -e 'qx(touch /output.txt)'
perl -e 'mkdir "/docs"'
[edit] PHP
<?php
touch('output.txt');
mkdir('docs');
touch('/output.txt');
mkdir('/docs');
?>
[edit] PicoLisp
(out "output.txt") # Empty output
(call 'mkdir "docs") # Call external
(out "/output.txt")
(call 'mkdir "/docs")
[edit] Pike
import Stdio;
int main(){
write_file("input.txt","",0100);
write_file("/input.txt","",0100);
}
[edit] PL/I
open file (output) title ('/OUTPUT.TXT,type(text),recsize(100)' );
close file (output);
[edit] PowerShell
New-Item output.txt -ItemType File
New-Item \output.txt -ItemType File
New-Item docs -ItemType Directory
New-Item \docs -ItemType Directory
[edit] PureBasic
CreateFile(0,"output.txt"):CloseFile(0)
CreateDirectory("docs")
CreateFile(0,"/output.txt"):CloseFile(0)
CreateDirectory("/docs")
[edit] Python
import os
for dir in ['/', './']:
open(dir + 'output.txt', 'w').close() # create /output.txt, then ./output.txt
os.mkdir(dir + 'docs') # create directory /docs, then ./docs
Works with: Python version 2.5 Exception-safe way to create file:
from __future__ import with_statement
import os
def create(dir):
with open(os.path.join(dir, "output.txt"), "w"):
pass
os.mkdir(os.path.join(dir, "docs"))
create(".") # current directory
create("/") # root directory
[edit] R
f <- file("output.txt", "w")
close(f)
# it may fails and the exact syntax to achieve the root
# changes according to the operating system
f <- file("/output.txt", "w")
close(f)
success <- dir.create("docs")
success <- dir.create("/docs")
[edit] Raven
"" as str
str 'output.txt' write
str '/output.txt' write
'docs' mkdir
'/docs' mkdir
[edit] Ruby
['/', './'].each{|dir|
Dir.mkdir(dir + 'docs') # create '/docs', then './docs'
File.open(dir + 'output.txt', 'w') {} # create empty file /output.txt, then ./output.txt
}
[edit] Scheme
(open-output-file "output.txt")
(open-output-file "/output.txt")
Results:
> file output.txt output.txt: empty > file /output.txt /output.txt: empty
I am not aware of any standard way of creating directories in Scheme.
[edit] Slate
File creation locally:
(File newNamed: 'output.txt') touch.
(Directory current / 'output.txt') touch.
File creation at root:
(File newNamed: '/output.txt') touch.
(Directory root / 'output.txt') touch.
[edit] Smalltalk
Squeak has no notion of 'current directory' because it isn't tied to the shell that created it.
(FileDirectory on: 'c:\') newFileNamed: 'output.txt'; createDirectory: 'docs'.
In GNU Smalltalk you can do instead:
ws := (File name: 'output.txt') writeStream.
ws close.
Directory create: 'docs'.
ws := (File name: '/output.txt') writeStream.
ws close.
Directory create: '/docs'.
[edit] Standard ML
let val out = TextIO.openOut "output.txt" in
TextIO.closeOut out
end;
OS.FileSys.mkDir "docs";
(for creation in the filesystem root, replace the filenames by "/output.txt" and "/docs")
[edit] 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 output.txt w]
close [open [file nativename /output.txt] w]
file mkdir docs
file mkdir [file nativename /docs]
[edit] Toka
needs shell
" 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
" /docs" &777 mkdir
[edit] 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.
// In current directory
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()
File_Mkdir("/docs")
[edit] Visual Basic .NET
Platform: .NET
Works with: Visual Basic .NET version 9.0+
'Current Directory
IO.Directory.CreateDirectory("docs")
IO.File.Create("output.txt").Close()
'Root
IO.Directory.CreateDirectory("\docs")
IO.File.Create("\output.txt").Close()
'Root, platform independent
IO.Directory.CreateDirectory(IO.Path.DirectorySeparatorChar & "docs")
IO.File.Create(IO.Path.DirectorySeparatorChar & "output.txt").Close()
[edit] UNIX Shell
Works with: bash
touch {/,}output.txt # create both /output.txt and output.txt
mkdir {/,}docs # create both /docs and docs
