这个版本在Windows上比上面的答案工作得更好，因为它同时理解/和路径。sep，以便向前斜杠在Windows上工作，因为他们应该。支持绝对路径和相对路径(相对于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;
}

更新

NodeJS 10.12.0版本增加了对mkdir和mkdirSync的本地支持，使用recursive: true选项递归地创建目录，如下所示:

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

如果你喜欢fs Promises API，你可以写

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

原来的答案

如果目录不存在，则递归地创建目录!(零依赖关系)

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

使用

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

试一试!

解释

[UPDATE] This solution handles platform-specific errors like EISDIR for Mac and EPERM and EACCES for Windows. Thanks to all the reporting comments by @PediT., @JohnQ, @deed02392, @robyoder and @Almenon. This solution handles both relative and absolute paths. Thanks to @john comment. 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 dir, 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 anti-pattern that leaves the code vulnerable to race conditions. Thanks to @GershomMaes comment about the directory existence check. Requires Node v6 and newer to support destructuring. (If you have problems implementing this solution with old Node versions, just leave me a comment)

一个更健壮的答案是使用use mkdirp。

var mkdirp = require('mkdirp');

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

然后继续将文件写入完整路径:

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

Exec在windows上可能很乱。还有一个更“nodie”的解决方案。基本上，您有一个递归调用来查看目录是否存在，并深入子目录(如果存在)或创建它。下面是一个函数，它将创建子函数，并在完成时调用一个函数:

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

}

一种选择是使用shelljs模块

npm install shelljs

var shell = require('shelljs');
shell.mkdir('-p', fullPath);

从那一页开始:

可用的选项: P:全路径(如有必要将创建中间dirs)

正如其他人所注意到的，还有其他更专注的模块。但是，除了mkdirp之外，它还有大量其他有用的shell操作(比如which, grep等等…)，并且它可以在windows和*nix上工作

编辑:评论建议这在没有mkdir cli实例的系统上不起作用。事实并非如此。这就是shelljs的重点——创建一个可移植的跨平台shell类函数集。它适用于偶数窗户。

找不到创建具有所需权限的目录的示例。

使用您想要的权限以异步递归方式创建目录。

下面是一个简单的nodejs解决方案

节点v18.12.1 Ubuntu 18

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