Make directory path: Difference between revisions

 

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

 

=={{header|Ada}}==

with Ada.Directories;

with Ada.Text_IO;

Ada.Directories.Create_Path (Path);

end;

 

=={{header|Aime}}==

mkdirp(text path)

{

 

0;

 

=={{header|AppleScript}}==

`createDirectoryAtPath:withIntermediateDirectories:attributes:error:`

 

use scripting additions

 

on nothing(msg)

{nothing:true, msg:msg}

 

=={{header|Arturo}}==

 

 

=={{header|AWK}}==

# syntax: GAWK -f MAKE_DIRECTORY_PATH.AWK path ...

BEGIN {

return system(cmd)

}

<p>sample command and output under Windows 8:</p>

<pre>

 

=={{header|C}}==

#include <stdlib.h>

#include <libgen.h>

}

return 0;

 

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

 

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

#include <filesystem>

#include <iostream>

}

}

 

=={{header|Clojure}}==

(let [dir (java.io.File. path)]

(if (.exists dir)

true

 

=={{header|Common Lisp}}==

(ensure-directories-exist "your/path/name")

 

=={{header|D}}==

 

void main() {

}

}

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{libheader| System.IOUtils}}

program Make_directory_path;

 

Writeln('Created "', path2, '" sucessfull.');

Readln;

 

=={{header|Elixir}}==

Tries to create the directory `path`. Missing parent directories are created.

 

=={{header|ERRE}}==

ERRE has the procedure "OS_MKDIR" in PC.LIB standard library, that creates a directory with

all missing parents. Existing directory are simply ignored.

 

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

=={{header|Factor}}==

The <code>make-directories</code> word performs this task. Note the value of <code>current-directory</code> is used as the base directory if a relative pathname is given.

The implementation of <code>make-directories</code>:

io.pathnames kernel sequences ;

IN: io.directories

normalize-path trim-tail-separators dup

{ [ "." = ] [ root-directory? ] [ empty? ] [ exists? ] } 1||

 

=={{header|Gambas}}==

 

If Not Exist(User.home &/ "TestFolder") Then Mkdir User.Home &/ "TestFolder"

 

 

=={{header|Go}}==

The standard packages include <tt>[http://golang.org/pkg/os/#MkdirAll os.MkdirAll]</tt> which does exactly this

(and its source is also available via that link).

 

=={{header|Haskell}}==

import System.Directory (createDirectory, setCurrentDirectory)

import Data.List.Split (splitOn)

let path = splitOn "/" "path/to/dir"

mapM_ (\x -> createDirectory x >> setCurrentDirectory x) path

 

=={{header|J}}==

The verb <code>pathcreate</code> in the addon package [http://www.jsoftware.com/jwiki/Addons/general/dirutils general/dirutils] will create any non-existing directories in a path. It works on Windows, Linux and OS X.

 

Code is similar to the following:

todir=. termsep_j_ jpathsep y

todirs=. }. ,each /\ <;.2 todir NB. base dirs

)

 

 

=={{header|Java}}==

The Java method for this is ''mkdirs'' and can be found in java.io.File. The source is in the ''src.zip'' of the JDK root directory.

 

public interface Test {

}

}

 

=={{header|JavaScript}}==

Simplified version of the popular [https://www.npmjs.org/package/mkdirp mkdirp library]:

 

var fs = require('fs');

 

}

});

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

=={{header|Kotlin}}==

 

import java.io.File

if (success) println("Directory path was created successfully")

else println("Failed to create directory path")

 

{{out}}

The ubiquitous luafilesystem module contains lfs.mkdir but this does not have an option equivalent to the posix mkdir -p.

Instead, the function shown here uses package.config to determine the correct directory separator for the OS and then iterates over the path string to create each individual folder in turn.

 

function mkdir (path)

end

 

Note that attempting to run lfs.mkdir for a path that already exists writes no changes to disk and returns nil.

 

Creates directory specified by path, creating intermediate directories as necessary, and never fails if path already exists.

 

=={{header|NewLISP}}==

(if (= "/" (mypath 0)) ;; Abs or relative path?

(setf /? "/")

;; ... or calling OS command directly.

(! "mkdir -p /tmp/rosetta/test2")

 

=={{header|Nim}}==

Note that the procedure "createDir" used here doesn’t raise an exception if the directory already exists because for current situations this is not an error. An exception is raised if the directory doesn’t exist after the call, if, for instance, permission is not allowed to create the directory.

 

try:

echo "Directory now exists."

except OSError:

 

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

System.IO.File.Directory->CreatePath("your/path/name")->PrintLine();

}

 

 

=={{header|OCaml}}==

 

 

=={{header|Perl}}==

Using the File::Path core module:

 

 

 

=={{header|Phix}}==

There's a builtin for that

The implementation in builtins/pfile.e is as follows (see there for initf() etc):

Of course you could also use system("mkdir -p path/to/dir") or whatever.

 

=={{header|PicoLisp}}==

 

=={{header|PowerShell}}==

New-Item -Path ".\path\to\dir" -ItemType Directory -ErrorAction SilentlyContinue

 

=={{header|Python}}==

from errno import EEXIST

from os import mkdir, curdir

if e.errno != EEXIST:

raise

 

Above is a modified version of the standard library's <code>os.makedirs</code>, for pedagogical purposes. In practice, you would be more likely to use the standard library call:

 

def mkdirp(path):

try:

pass

else: raise

 

In Python3 this becomes even simpler:

 

def mkdirp(path):

os.makedirs(path, exist_ok=True)

 

=={{header|Racket}}==

</blockquote>

 

(define path-str "/tmp/woo/yay")

(define path/..-str "/tmp/woo")

(make-directory* path-str)

 

 

{{out}}

There is a built-in function for this:

 

 

Alternatively, a custom solution (as per task description) that only uses the built-in <tt>mkdir</tt> non-recursively. The "triangle reduce" meta-operator <code>[\ ]</code> is used get the intermediate results of a left fold with the comma operator on the list of path elements.

 

mkdir $_ unless .e given $*SPEC.catdir(@path).IO;

 

=={{header|REXX}}==

 

Usage note: &nbsp; without the error messages being suppressed, the &nbsp; '''MKDIR''' &nbsp; command will issue an error message if the subdirectory (or its path) already exists.

trace off /*suppress possible warning msgs.*/

 

 

'MKDIR' dPath "2>nul" /*alias could be used: MD dPath */

 

=={{header|Ring}}==

System("mkdir C:\Ring\docs")

isdir("C:\Ring\docs")

return false

done

 

=={{header|Ruby}}==

mkdir_p also takes an array of pathnames instead of a single pathname as an argument.

mkdir_p is aliased as: mkpath, makedirs.

 

=={{header|Run BASIC}}==

files #f, "c:\myDocs" ' check for directory

if #f hasanswer() then

else

shell$("mkdir c:\myDocs" ' if not exist make a directory

The following info about files / directory

FILE ACCESSOR methods

 

=={{header|Rust}}==

 

fn main() {

fs::create_dir_all("./path/to/dir").expect("An Error Occured!")

 

=={{header|Scala}}==

Alternative (platform-independent) for the library function:

 

def mkdirs(path: List[String]) = // return true if path was created

 

mkdirs(List("/path", "to", "dir"))

 

=={{header|Seed7}}==

defines the function doMkdirCmd, which is used below.

 

include "cli_cmds.s7i";

 

begin

doMkdirCmd(argv(PROGRAM), TRUE);

 

The library cli_cmds.s7i defines also

The function doMkdir is used in the alternate solution below:

 

include "cli_cmds.s7i";

 

parameters := join(argv(PROGRAM), " ");

doMkdir(parameters);

 

=={{header|Sidef}}==

 

=={{header|Tcl}}==

Tcl's built in <code>file mkdir</code> works exactly this way:

If a directory cannot be made (e.g., because it would involve making a directory with the same name as an existing file) the command will throw a trappable error, as normal for Tcl commands.

 

{{works with|Bourne Again SHell}}

 

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Sub Main()

End Sub

 

 

=={{header|zkl}}==

This is for Unix as zkl doesn't have a built in mkdir method.

The system error code is returned (0 in this case).

{{out}}

<pre>