Node.js create folder or use existing
Javascriptnode.jsJavascript Problem Overview
I already have read the documentation of Node.js and, unless if I missed something, it does not tell what the parameters contain in certain operations, in particular fs.mkdir()
. As you can see in the documentation, it's not very much.
Currently, I have this code, which tries to create a folder or use an existing one instead:
fs.mkdir(path,function(e){
if(!e || (e && e.code === 'EEXIST')){
//do something with contents
} else {
//debug
console.log(e);
}
});
But I wonder is this the right way to do it? Is checking for the code EEXIST
the right way to know that the folder already exists? I know I can do fs.stat()
before making the directory, but that would already be two hits to the filesystem.
Secondly, is there a complete or at least a more detailed documentation of Node.js that contains details as to what error objects contain, what parameters signify etc.
Javascript Solutions
Solution 1 - Javascript
Edit: Because this answer is very popular, I have updated it to reflect up-to-date practices.
Node >=10
The new { recursive: true }
option of Node's fs
now allows this natively. This option mimics the behaviour of UNIX's mkdir -p
. It will recursively make sure every part of the path exist, and will not throw an error if any of them do.
(Note: it might still throw errors such as EPERM
or EACCESS
, so better still wrap it in a try {} catch (e) {}
if your implementation is susceptible to it.)
Synchronous version.
fs.mkdirSync(dirpath, { recursive: true })
Async version
await fs.promises.mkdir(dirpath, { recursive: true })
Older Node versions
Using a try {} catch (err) {}
, you can achieve this very gracefully without encountering a race condition.
In order to prevent dead time between checking for existence and creating the directory, we simply try to create it straight up, and disregard the error if it is EEXIST
(directory already exists).
If the error is not EEXIST
, however, we ought to throw an error, because we could be dealing with something like an EPERM
or EACCES
function ensureDirSync (dirpath) {
try {
return fs.mkdirSync(dirpath)
} catch (err) {
if (err.code !== 'EEXIST') throw err
}
}
For mkdir -p
-like recursive behaviour, e.g. ./a/b/c
, you'd have to call it on every part of the dirpath, e.g. ./a
, ./a/b
, .a/b/c
Solution 2 - Javascript
Good way to do this is to use mkdirp module.
$ npm install mkdirp
Use it to run function that requires the directory. Callback is called after path is created or if path did already exists. Error err
is set if mkdirp failed to create directory path.
var mkdirp = require('mkdirp');
mkdirp('/tmp/some/path/foo', function(err) {
// path exists unless there was an error
});
Solution 3 - Javascript
If you want a quick-and-dirty one liner, use this:
fs.existsSync("directory") || fs.mkdirSync("directory");
Solution 4 - Javascript
The node.js docs for fs.mkdir
basically defer to the Linux man page for mkdir(2)
. That indicates that EEXIST
will also be indicated if the path exists but isn't a directory which creates an awkward corner case if you go this route.
You may be better off calling fs.stat
which will tell you whether the path exists and if it's a directory in a single call. For (what I'm assuming is) the normal case where the directory already exists, it's only a single filesystem hit.
These fs
module methods are thin wrappers around the native C APIs so you've got to check the man pages referenced in the node.js docs for the details.
Solution 5 - Javascript
You can use this:
if(!fs.existsSync("directory")){
fs.mkdirSync("directory", 0766, function(err){
if(err){
console.log(err);
// echo the result back
response.send("ERROR! Can't make the directory! \n");
}
});
}
Solution 6 - Javascript
I propose a solution without modules (accumulate modules is never recommended for maintainability especially for small functions that can be written in a few lines...) :
LAST UPDATE :
In v10.12.0, NodeJS impletement recursive options :
// Create recursive folder
fs.mkdir('my/new/folder/create', { recursive: true }, (err) => { if (err) throw err; });
UPDATE :
// Get modules node
const fs = require('fs');
const path = require('path');
// Create
function mkdirpath(dirPath)
{
if(!fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK))
{
try
{
fs.mkdirSync(dirPath);
}
catch(e)
{
mkdirpath(path.dirname(dirPath));
mkdirpath(dirPath);
}
}
}
// Create folder path
mkdirpath('my/new/folder/create');
Solution 7 - Javascript
You can also use [fs-extra][1], which provide a lot frequently used file operations.
Sample Code:
var fs = require('fs-extra')
fs.mkdirs('/tmp/some/long/path/that/prob/doesnt/exist', function (err) {
if (err) return console.error(err)
console.log("success!")
})
fs.mkdirsSync('/tmp/another/path')
docs here: https://github.com/jprichardson/node-fs-extra#mkdirsdir-callback [1]: https://github.com/jprichardson/node-fs-extra
Solution 8 - Javascript
Here is the ES6 code which I use to create a directory (when it doesn't exist):
const fs = require('fs');
const path = require('path');
function createDirectory(directoryPath) {
const directory = path.normalize(directoryPath);
return new Promise((resolve, reject) => {
fs.stat(directory, (error) => {
if (error) {
if (error.code === 'ENOENT') {
fs.mkdir(directory, (error) => {
if (error) {
reject(error);
} else {
resolve(directory);
}
});
} else {
reject(error);
}
} else {
resolve(directory);
}
});
});
}
const directoryPath = `${__dirname}/test`;
createDirectory(directoryPath).then((path) => {
console.log(`Successfully created directory: '${path}'`);
}).catch((error) => {
console.log(`Problem creating directory: ${error.message}`)
});
Note:
- In the beginning of the
createDirectory
function, I normalize the path to guarantee that the path seperator type of the operating system will be used consistently (e.g. this will turnC:\directory/test
intoC:\directory\test
(when being on Windows) fs.exists
is deprecated, that's why I usefs.stat
to check if the directory already exists- If a directory doesn't exist, the error code will be
ENOENT
(Error NO ENTry) - The directory itself will be created using
fs.mkdir
- I prefer the asynchronous function
fs.mkdir
over it's blocking counterpartfs.mkdirSync
and because of the wrappingPromise
it will be guaranteed that the path of the directory will only be returned after the directory has been successfully created
Solution 9 - Javascript
You'd better not to count the filesystem hits while you code in Javascript, in my opinion.
However, (1) stat
& mkdir
and (2) mkdir
and check(or discard) the error code, both ways are right ways to do what you want.
Solution 10 - Javascript
> create dynamic name directory for each user... use this code
***suppose email contain user mail address***
var filessystem = require('fs');
var dir = './public/uploads/'+email;
if (!filessystem.existsSync(dir)){
filessystem.mkdirSync(dir);
}else
{
console.log("Directory already exist");
}
Solution 11 - Javascript
Just as a newer alternative to Teemu Ikonen's answer, which is very simple and easily readable, is to use the ensureDir
method of the fs-extra
package.
It can not only be used as a blatant replacement for the built in fs
module, but also has a lot of other functionalities in addition to the functionalities of the fs
package.
The ensureDir
method, as the name suggests, ensures that the directory exists. If the directory structure does not exist, it is created. Like mkdir -p
. Not just the end folder, instead the entire path is created if not existing already.
the one provided above is the async
version of it. It also has a synchronous method to perform this in the form of the ensureDirSync
method.
Solution 12 - Javascript
You can do all of this with the File System module.
const
fs = require('fs'),
dirPath = `path/to/dir`
// Check if directory exists.
fs.access(dirPath, fs.constants.F_OK, (err)=>{
if (err){
// Create directory if directory does not exist.
fs.mkdir(dirPath, {recursive:true}, (err)=>{
if (err) console.log(`Error creating directory: ${err}`)
else console.log('Directory created successfully.')
})
}
// Directory now exists.
})
You really don't even need to check if the directory exists. The following code also guarantees that the directory either already exists or is created.
const
fs = require('fs'),
dirPath = `path/to/dir`
// Create directory if directory does not exist.
fs.mkdir(dirPath, {recursive:true}, (err)=>{
if (err) console.log(`Error creating directory: ${err}`)
// Directory now exists.
})
Solution 13 - Javascript
@Liberateur's answer above did not work for me (Node v8.10.0). Little modification did the trick but I am not sure if this is a right way. Please suggest.
// Get modules node
const fs = require('fs');
const path = require('path');
// Create
function mkdirpath(dirPath)
{
try {
fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
}
catch(err) {
try
{
fs.mkdirSync(dirPath);
}
catch(e)
{
mkdirpath(path.dirname(dirPath));
mkdirpath(dirPath);
}
}
}
// Create folder path
mkdirpath('my/new/folder/create');
Solution 14 - Javascript
Raugaral's answer but with -p functionality. Ugly, but it works:
function mkdirp(dir) {
let dirs = dir.split(/\\/).filter(asdf => !asdf.match(/^\s*$/))
let fullpath = ''
// Production directory will begin \\, test is on my local drive.
if (dirs[0].match(/C:/i)) {
fullpath = dirs[0] + '\\'
}
else {
fullpath = '\\\\' + dirs[0] + '\\'
}
// Start from root directory + 1, build out one level at a time.
dirs.slice(1).map(asdf => {
fullpath += asdf + '\\'
if (!fs.existsSync(fullpath)) {
fs.mkdirSync(fullpath)
}
})
}//mkdirp