How can I create a full path with Node.js' "fs.mkdirSync"?

Node.js version 10.12.0 and later

Node.js version 10.12.0 has added a native support for both mkdir and mkdirSync to create a directory recursively with recursive: true option as the following:

fs.mkdirSync(targetDir, { recursive: true }); 

And if you prefer fs Promises API, you can write

fs.promises.mkdir(targetDir, { recursive: true }); 

Before Node.js version 10.12.0

Create directories recursively if they do not exist! (Zero dependencies)

const fs = require('fs'); const path = require('path'); function mkDirByPathSync(targetDir, { isRelativeToScript = false } = {}) { const sep = path.sep; const initDir = path.isAbsolute(targetDir) ? sep : ''; const baseDir = isRelativeToScript ? __dirname : '.'; return targetDir.split(sep).reduce((parentDir, childDir) => { const curDir = path.resolve(baseDir, parentDir, childDir); try { fs.mkdirSync(curDir); } catch (err) { if (err.code === 'EEXIST') { // curDir already exists! return curDir; } // To avoid `EISDIR` error on Mac and `EACCES`-->`ENOENT` and `EPERM` on Windows. if (err.code === 'ENOENT') { // Throw the original parentDir error on curDir `ENOENT` failure. throw new Error(`EACCES: permission denied, mkdir '${parentDir}'`); } const caughtErr = ['EACCES', 'EPERM', 'EISDIR'].indexOf(err.code) > -1; if (!caughtErr || caughtErr && curDir === path.resolve(targetDir)) { throw err; // Throw if it's just the last created dir. } } return curDir; }, initDir); } 

Usage

// Default, make directories relative to current working directory. mkDirByPathSync('path/to/dir'); // Make directories relative to the current script. mkDirByPathSync('path/to/dir', {isRelativeToScript: true}); // Make directories with an absolute path. mkDirByPathSync('/path/to/dir'); 

Demo

Try It!

Explanations

• This solution handles platform-specific errors like EISDIR for Mac and EPERM and EACCES for Windows.
• This solution handles both relative and absolute paths.
• In the case of relative paths, target directories will be created (resolved) in the current working directory. To Resolve them relative to the current script directory, pass {isRelativeToScript: true}.
• Using path.sep and path.resolve(), not just / concatenation, to avoid cross-platform issues.
• Using fs.mkdirSync and handling the error with try/catch if thrown to handle race conditions: another process may add the file between the calls to fs.existsSync() and fs.mkdirSync() and causes an exception.
  • The other way to achieve that could be checking if a file exists then creating it, I.e, if (!fs.existsSync(curDir) fs.mkdirSync(curDir);. But this is an antipattern that leaves the code vulnerable to race conditions.
• Requires Node.js v6 and newer to support destructuring assignment.

A more robust answer is to use use mkdirp.

var mkdirp = require('mkdirp'); mkdirp('/path/to/dir', function (err) { if (err) console.error(err) else console.log('dir created') }); 

Then proceed to write the file into the full path with:

fs.writeFile ('/path/to/dir/file.dat'.... 

fs-extra adds file system methods that aren't included in the native fs module. It is a drop-in replacement for fs.

Install fs-extra:

npm install --save fs-extra 

Usage:

const fs = require("fs-extra"); // Make sure the output directory is there. fs.ensureDirSync(newDest); 

There are sync and async options.

Reference: ensureDir(dir[,options][,callback])

Using reduce, we can verify if each path exists and create it if necessary. Also this way, I think, is easier to follow. We should use path.sep to get the proper platform-specific path segment separator.

const path = require('path'); // Path separators could change depending on the platform const pathToCreate = 'path/to/directory'; pathToCreate .split(path.sep) .reduce((prevPath, folder) => { const currentPath = path.join(prevPath, folder, path.sep); if (!fs.existsSync(currentPath)){ fs.mkdirSync(currentPath); } return currentPath; }, ''); 

This feature has been added to Node.js in version 10.12.0, so it's as easy as passing an option {recursive: true} as second argument to the fs.mkdir() call.

See the example in the official documentation.

There isn't any need for external modules or your own implementation.

I know this is an old question, but Node.js v10.12.0 now supports this natively with the recursive option set to true. fs.mkdir:

// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist. fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => { if (err) throw err; }); 

Now with Node.js 10.12.0 or later, you can use fs.mkdirSync(path, { recursive: true }).

See fs.mkdirSync.

Example for Windows (no extra dependencies and error handling)

const path = require('path'); const fs = require('fs'); let dir = "C:\\temp\\dir1\\dir2\\dir3"; function createDirRecursively(dir) { if (!fs.existsSync(dir)) { createDirRecursively(path.join(dir, "..")); fs.mkdirSync(dir); } } createDirRecursively(dir); //creates dir1\dir2\dir3 in C:\temp 

You can simply check if the folder exists or not in the path recursively and make the folder as you check if they are not present. (Note: That doesn't require any external library)

function checkAndCreateDestinationPath (fileDestination) { const dirPath = fileDestination.split('/'); dirPath.forEach((element, index) => { if(!fs.existsSync(dirPath.slice(0, index + 1).join('/'))) { fs.mkdirSync(dirPath.slice(0, index + 1).join('/')); } }); } 

You can use the following function:

const recursiveUpload = (path: string) => { const paths = path.split("/") const fullPath = paths.reduce((accumulator, current) => { fs.mkdirSync(accumulator) return `${accumulator}/${current}` }) fs.mkdirSync(fullPath) return fullPath } 

It:

1. Creates a paths variable, where it stores every path by itself as an element of the array.

2. Adds "/" at the end of each element in the array.

3. Makes for the cycle:

   1. Creates a directory from the concatenation of array elements which indexes are from 0 to current iteration. Basically, it is recursive.

By the way, in Node.js v10.12.0 you can use recursive path creation by giving it as the additional argument.

fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => { if (err) throw err; }); 

See also fs.mkdirSync(path[, options]).

Here's a solution without recursion that works by splitting the path and then left-to-right building it back up again:

function mkdirRecursiveSync(path) { let paths = path.split(path.delimiter); let fullPath = ''; paths.forEach((path) => { if (fullPath === '') { fullPath = path; } else { fullPath = fullPath + '/' + path; } if (!fs.existsSync(fullPath)) { fs.mkdirSync(fullPath); } }); }; 

For those concerned about Windows vs Linux compatibility, simply replace the forward slash with double backslash '\' in both occurrence above, but to be honest we are talking about Node.js' fs, not Windows command line. The former is pretty forgiving, and the above code will simply work on Windows and is more a complete solution cross platform.

An asynchronous way to create directories recursively:

import fs from 'fs' const mkdirRecursive = function(path, callback) { let controlledPaths = [] let paths = path.split( '/' // Put each path in an array ).filter( p => p != '.' // Skip root path indicator (.) ).reduce((memo, item) => { // Previous item prepended to each item so we preserve realpaths const prevItem = memo.length > 0 ? memo.join('/').replace(/\.\//g, '')+'/' : '' controlledPaths.push('./'+prevItem+item) return [...memo, './'+prevItem+item] }, []).map(dir => { fs.mkdir(dir, err => { if (err && err.code != 'EEXIST') throw err // Delete created directory (or skipped) from controlledPath controlledPaths.splice(controlledPaths.indexOf(dir), 1) if (controlledPaths.length === 0) { return callback() } }) }) } // Usage mkdirRecursive('./photos/recent', () => { console.log('Directories created succesfully!') }) 

As clean as this :)

function makedir(fullpath) { let destination_split = fullpath.replace('/', '\\').split('\\') let path_builder = destination_split[0] $.each(destination_split, function (i, path_segment) { if (i < 1) return true path_builder += '\\' + path_segment if (!fs.existsSync(path_builder)) { fs.mkdirSync(path_builder) } }) } 

I solved the problem this way - similar to other recursive answers but to me this is much easier to understand and read.

const path = require('path'); const fs = require('fs'); function mkdirRecurse(inputPath) { if (fs.existsSync(inputPath)) { return; } const basePath = path.dirname(inputPath); if (fs.existsSync(basePath)) { fs.mkdirSync(inputPath); } mkdirRecurse(basePath); } 

Here's my imperative version of mkdirp for Node.js.

function mkdirSyncP(location) { let normalizedPath = path.normalize(location); let parsedPathObj = path.parse(normalizedPath); let curDir = parsedPathObj.root; let folders = parsedPathObj.dir.split(path.sep); folders.push(parsedPathObj.base); for(let part of folders) { curDir = path.join(curDir, part); if (!fs.existsSync(curDir)) { fs.mkdirSync(curDir); } } } 

Use this approach:

if (!fs.existsSync(pathToFile)) { var dirName = ""; var filePathSplit = pathToFile.split('/'); for (var index = 0; index < filePathSplit.length; index++) { dirName += filePathSplit[index] + '/'; if (!fs.existsSync(dirName)) fs.mkdirSync(dirName); } } 

This works for relative path.

Based on mouneer's zero-dependencies answer, here's a slightly more beginner friendly TypeScript variant, as a module:

import * as fs from 'fs'; import * as path from 'path'; /** * Recursively creates directories until `targetDir` is valid. * @param targetDir: Target directory path to be created recursively. * @param isRelative: Is the provided `targetDir` a relative path? */ export function mkdirRecursiveSync(targetDir: string, isRelative = false) { const sep = path.sep; const initDir = path.isAbsolute(targetDir) ? sep : ''; const baseDir = isRelative ? __dirname : '.'; targetDir.split(sep).reduce((prevDirPath, dirToCreate) => { const curDirPathToCreate = path.resolve(baseDir, prevDirPath, dirToCreate); try { fs.mkdirSync(curDirPathToCreate); } catch (err) { if (err.code !== 'EEXIST') { throw err; } // caught EEXIST error if curDirPathToCreate already existed (not a problem for us). } return curDirPathToCreate; // Becomes prevDirPath on the next call to reduce }, initDir); } 

Use:

const fs = require('fs'); try { fs.mkdirSync(path, { recursive: true }); } catch (error) { // This makes the script keep running, even when the folder already exists console.log(error); } 

I had issues with the recursive option of fs.mkdir, so I made a function that does the following:

1. Creates a list of all directories, starting with the final target directory and working up to the root parent.

2. Creates a new list of needed directories for the mkdir function to work

3. Makes each directory needed, including the final

    function createDirectoryIfNotExistsRecursive(dirname) { return new Promise((resolve, reject) => { const fs = require('fs'); var slash = '/'; // Backward slashes for Windows if(require('os').platform() === 'win32') { slash = '\\'; } // Initialize directories with the final directory var directories_backwards = [dirname]; var minimize_dir = dirname; while (minimize_dir = minimize_dir.substring(0, minimize_dir.lastIndexOf(slash))) { directories_backwards.push(minimize_dir); } var directories_needed = []; // Stop on the first directory found for(const d in directories_backwards) { if(!(fs.existsSync(directories_backwards[d]))) { directories_needed.push(directories_backwards[d]); } else { break; } } // No directories missing if(!directories_needed.length) { return resolve(); } // Make all directories in ascending order var directories_forwards = directories_needed.reverse(); for(const d in directories_forwards) { fs.mkdirSync(directories_forwards[d]); } return resolve(); }); } 

I could not find an example to create directories with the required permissions.

Create directories async recursively with the permissions you want.

Here’s a plain Node.js solution:

• Node.js v18.12.1
• Ubuntu 18.04 (Bionic Beaver)

Code

// ----------------------------- const fs = require('fs'); const fsPromises = fs.promises; const checkDirAccess = async (userDir) => { try { await fsPromises.access(userDir, fs.constants.R_OK | fs.constants.W_OK); console.log(` ${userDir} Dir existss`); return userDir; } catch (err) { if(err.errno = -2) return await crDir(userDir); else throw err; } } const crDir = async (userDir) => { try { let newDir = await fsPromises.mkdir(userDir, { recursive: true, mode: 0o700}); // When userDir is created; newDir = undefined; console.log(` Created new Dir ${newDir}`); return newDir; } catch (err) { throw err; } } const directoryPath = ['uploads/xvc/xvc/xvc/specs', 'uploads/testDir11', 'uploads/xsXa/', 'uploads//xsb//', 'uploads//xsV/']; const findDir = async() => { try { for (const iterator of directoryPath) { let dirOK = await checkDirAccess(iterator); if(dirOK) console.log(`found ${dirOK}`) } } catch (error) { console.error('Error: ', error); } } 

Exec can be messy on Windows. There is a more "nodie" solution.

Fundamentally, you have a recursive call to see if a directory exists and dive into the child (if it does exist) or create it. Here is a function that will create the children and call a function when finished:

fs = require('fs'); makedirs = function(path, func) { var pth = path.replace(/['\\] + /g, '/'); var els = pth.split('/'); var all = ""; (function insertOne() { var el = els.splice(0, 1)[0]; if (!fs.existsSync(all + el)) { fs.mkdirSync(all + el); } all += el + "/"; if (els.length == 0) { func(); } else { insertOne(); } })(); } 

This version works better on Windows than the top answer, because it understands both / and path.sep, so that forward slashes work on Windows as they should. It supports absolute and relative paths (relative to the process.cwd).

/** * Creates a folder and if necessary, parent folders also. Returns true * if any folders were created. Understands both '/' and path.sep as * path separators. Doesn't try to create folders that already exist, * which could cause a permissions error. Gracefully handles the race * condition if two processes are creating a folder. Throws on error. * @param targetDir Name of folder to create */ export function mkdirSyncRecursive(targetDir) { if (!fs.existsSync(targetDir)) { for (var i = targetDir.length-2; i >= 0; i--) { if (targetDir.charAt(i) == '/' || targetDir.charAt(i) == path.sep) { mkdirSyncRecursive(targetDir.slice(0, i)); break; } } try { fs.mkdirSync(targetDir); return true; } catch (err) { if (err.code !== 'EEXIST') throw err; } } return false; }