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

Jump to: navigation, search
Create a file is a programming task. Visitors like you are encouraged to solve it according to the task description, using any language they may happen to know.
Add to BlogMarksAdd to del.icio.usAdd to diggAdd to NewsvineAdd to redditAdd to Slashdot

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.

Contents

[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
Personal tools
Google AdSense