Create a file

Create a file
You are encouraged to solve this task according to the task description, using any language you may know.

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.

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.

<lang ada>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;</lang>

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);
)

AutoHotkey

<lang AutoHotkey>FileAppend,,output.txt FileCreateDir, docs FileAppend,,c:\output.txt FileCreateDir, c:\docs</lang>

AWK

There's no way to create a directory, except by calling an extern program (like mkdir) to do so. <lang awk>BEGIN {

 printf "" > "output.txt"
 # try to create the file in the root (for *nix-like systems)
 printf "" > "/output.txt"

}</lang>

C

<lang c>#include <stdio.h>

int main() {

 FILE *fh = fopen("output.txt", "w");
 fclose(fh);

 return 0;

}</lang>

Works with: POSIX

<lang c>#include <sys/stat.h>

int main() {

 mkdir("docs", 0750); /* rights 0750 for rwxr-x--- */

 return 0;

}</lang>

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

C++

<lang cpp>#include <fstream>

1. 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; }</lang>

C#

<lang csharp>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");
   }

}</lang>

Common Lisp

Lisp provides open and close commands for I/O with files<lang lisp>(let ((stream (open "output.txt" :direction :output)))

 (close stream))</lang>

but it is more common to use with-open-file which has better exception handling. <lang lisp>(with-open-file (stream "output.txt" :direction :output)

   ;; use the stream here
)</lang>

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 <lang lisp>(let ((paths (list (make-pathname :directory '(:relative "docs"))

                    (make-pathname :directory '(:absolute "docs")))))
 (mapcar #'ensure-directories-exist paths))</lang>

So creating a file called output.txt with an absolute path in the root directory becomes: <lang lisp>(with-open-file

   (stream 
       (make-pathname :directory '(:absolute "") :name "output.txt")
       :direction :output))</lang>

On the other hand, if you may depend on the platform's pathname syntax then shorter notation may be used: <lang lisp>(mapcar #'ensure-directories-exist '(#p"docs/" #p"/docs/")))</lang>

D

For file creation, std.file.write function & std.stream.file class are used.
For dir creation, std.file.mkdir is used. <lang d>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") ;

}</lang>

DOS Batch File

 md docs
 md \docs

E

<lang e><file:output.txt>.setBytes([]) <file:docs>.mkdir(null) <file:///output.txt>.setBytes([]) <file:///docs>.mkdir(null)</lang>

Forth

There is no means to create directories in ANS Forth. <lang forth> s" output.txt" w/o create-file throw ( fileid) drop

s" /output.txt" w/o create-file throw ( fileid) drop</lang>

Fortran

Works with: Fortran version 90 and later

Don't know a way of creating directories in Fortran <lang 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)</lang>

Haskell

<lang haskell>import System.Directory

createFile name = writeFile name ""

main = do

 createFile "output.txt"
 createDirectory "docs"
 createFile "/output.txt"
 createDirectory "/docs"</lang>

Java

<lang java5>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);
  }

}</lang>

MAXScript

-- Here
f = createFile "output.txt"
close f
makeDir (sysInfo.currentDir + "\docs")
-- System root
f = createFile "\output.txt"
close f
makeDir ("c:\docs")

Objective-C

<lang objc>NSFileManager *fm = [NSFileManager defaultManager];

[fm createFileAtPath:@"output.txt" contents:[NSData data] attributes:nil]; [fm createDirectoryAtPath:@"docs" attributes:nil];</lang>

OCaml

<lang ocaml># let oc = open_out "output.txt" in

 close_out oc;;

- : unit = ()

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

- : unit = ()</lang>

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

Perl

<lang 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';

};</lang>

Without Perl Modules

Current directory <lang perl>perl -e 'qx(touch output.txt)' perl -e 'mkdir docs'</lang>

Root directory <lang perl>perl -e 'qx(touch /output.txt)' perl -e 'mkdir "/docs"'</lang>

Python

Current directory

<lang python> import os

f = open("output.txt", "w")
f.close()
os.mkdir("docs")</lang>

Root directory

<lang python> f = open("/output.txt", "w")

f.close()
os.mkdir("/docs")</lang>

Works with: Python version 2.5

Exception-safe way to create file:

<lang python> 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</lang>

R

<lang R>f <- file("output.txt", "w") close(f)

1. it may fails and the exact syntax to achieve the root
2. changes according to the operating system

f <- file("/output.txt", "w") close(f)

success <- dir.create("docs") success <- dir.create("/docs")</lang>

Raven

"" as str
str 'output.txt'  write
str '/output.txt' write
'docs'  mkdir
'/docs' mkdir

Ruby

<lang ruby># Current directory open("output.txt", "w") { } Dir.mkdir("docs")

1. Root directory

open("/output.txt", "w") { } Dir.mkdir("/docs")</lang>

Slate

File creation locally: <lang slate>(File newNamed: 'output.txt') touch. (Directory current / 'output.txt') touch.</lang>

File creation at root: <lang slate>(File newNamed: '/output.txt') touch. (Directory root / 'output.txt') touch.</lang>

Smalltalk

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

<lang smalltalk>(FileDirectory on: 'c:\') newFileNamed: 'output.txt'; createDirectory: 'docs'.</lang>

In GNU Smalltalk you can do instead:

<lang smalltalk>ws := (File name: 'output.txt') writeStream. ws close. Directory create: 'docs'.

ws := (File name: '/output.txt') writeStream. ws close. Directory create: '/docs'.</lang>

Standard ML

<lang sml>let val out = TextIO.openOut "output.txt" in

 TextIO.closeOut out

end;

OS.FileSys.mkDir "docs";</lang>

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

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):

<lang tcl>close [open output.txt w] close [open [file nativename /output.txt] w]

file mkdir docs file mkdir [file nativename /docs]</lang>

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

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. <lang vedit>// 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")</lang>

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

<lang vb> '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()</lang>

UNIX Shell

Works with: bash

<lang bash>touch output.txt touch /output.txt mkdir docs mkdir /docs</lang>