Como criar o caminho completo com o fs.mkdirSync do nó?

Estou tentando criar um caminho completo se ele não existir.

O código fica assim:

var fs = require('fs');
if (!fs.existsSync(newDest)) fs.mkdirSync(newDest); 

Esse código funciona muito bem, desde que haja apenas um subdiretório (um newDest como 'dir1'), mas quando existe um caminho de diretório como ('dir1 / dir2'), ele falha com o Erro: ENOENT, nenhum arquivo ou diretório desse tipo

Eu gostaria de poder criar o caminho completo com o mínimo de linhas de código necessárias.

Eu li que há uma opção recursiva no fs e tentei assim

var fs = require('fs');
if (!fs.existsSync(newDest)) fs.mkdirSync(newDest,'0777', true);

Eu sinto que deveria ser tão simples criar recursivamente um diretório que não existe. Estou faltando alguma coisa ou preciso analisar o caminho e verificar cada diretório e criá-lo, se ele ainda não existir?

Eu sou muito novo no Node. Talvez eu esteja usando uma versão antiga do FS?

Uma opção é usar o módulo shelljs

npm install shelljs

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

A partir dessa página:

Opções disponíveis:

p: caminho completo (criará dirs intermediários, se necessário)

Como outros observaram, há outros módulos mais focados. Mas, fora do mkdirp, ele tem várias outras operações úteis do shell (como qual, grep etc ...) e funciona no windows e * nix

Editar

A versão do NodeJS 10.12.0adicionou um suporte nativo para ambos mkdire mkdirSyncpara criar um diretório recursivamente com a recursive: trueopção como a seguir:

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

E se você preferir fs Promises API, você pode escrever

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

Resposta original

Crie diretórios recursivamente se eles não existirem! ( Zero dependências )

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

Uso

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

Tente!

Explicações

• [UPDATE] Esta solução lida com erros específicos da plataforma, como EISDIRno Mac EPERMe EACCESno Windows. Obrigado a todos os comentários de @PediT., @JohnQ, @ deed02392, @robyoder e @Almenon.
• Esta solução lida com caminhos relativos e absolutos . Graças ao comentário @john.
• No caso de caminhos relativos, os diretórios de destino serão criados (resolvidos) no diretório de trabalho atual. Para resolvê-los em relação ao diretório de script atual, passe {isRelativeToScript: true}.
• Usando path.sepe path.resolve()não apenas /concatenação, para evitar problemas entre plataformas.
• Usando fs.mkdirSynce manusear o erro com try/catchse jogado para lidar com as condições de corrida: outro processo pode adicionar o arquivo entre as chamadas para fs.existsSync()e fs.mkdirSync()e causa uma exceção.
  • A outra maneira de conseguir isso seria verificar se existe um arquivo e criá-lo, ou seja if (!fs.existsSync(curDir) fs.mkdirSync(curDir);,. Mas esse é um antipadrão que deixa o código vulnerável às condições de corrida. Graças ao comentário de @GershomMaes sobre a verificação de existência do diretório.
• Requer o Nó v6 e mais recente para suportar a desestruturação. (Se você tiver problemas para implementar esta solução com versões antigas do Node, deixe-me um comentário)

Uma resposta mais robusta é usar o uso mkdirp .

var mkdirp = require('mkdirp');

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

Em seguida, continue a escrever o arquivo no caminho completo com:

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

fs-extra adiciona métodos de sistema de arquivos que não estão incluídos no módulo fs nativo. É uma queda no substituto do fs.

Instalar fs-extra

$ npm install --save fs-extra

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

Existem opções de sincronização e assíncrona.

https://github.com/jprichardson/node-fs-extra/blob/master/docs/ensureDir.md

Usando reduzir podemos verificar se cada caminho existe e criá-lo, se necessário, também desta forma acho que é mais fácil seguir. Editado, graças a @Arvin, devemos usar path.sep para obter o separador de segmento de caminho específico da plataforma.

const path = require('path');

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

Esse recurso foi adicionado ao node.js na versão 10.12.0, portanto, é tão fácil quanto passar uma opção {recursive: true}como segundo argumento para a fs.mkdir()chamada. Veja o exemplo nos documentos oficiais .

Não há necessidade de módulos externos ou sua própria implementação.

Eu sei que esta é uma pergunta antiga, mas o nodejs v10.12.0 agora suporta isso nativamente com a recursiveopção definida como 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;
});

Agora com NodeJS> = 10.12.0, você pode usar fs.mkdirSync(path, { recursive: true }) fs.mkdirSync

Exemplo para Windows (sem dependências extras e tratamento de erros)

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

Você pode simplesmente verificar se a pasta existe ou não no caminho recursivamente e criar a pasta conforme você verifica se elas não estão presentes. ( SEM BIBLIOTECA EXTERNA )

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

Você pode usar a próxima função

const recursiveUpload = (caminho: string) => {caminhos constantes = caminho.split ("/")

const fullPath = paths.reduce((accumulator, current) => {
  fs.mkdirSync(accumulator)
  return `${accumulator}/${current}`
  })

  fs.mkdirSync(fullPath)

  return fullPath
}

Então, o que faz:

1. Crio paths variável, onde ele armazena todos os caminhos por si só como um elemento da matriz.
2. Adiciona "/" no final de cada elemento da matriz.
3. Faz para o ciclo:
   1. Cria um diretório a partir da concatenação dos elementos da matriz cujos índices são de 0 à iteração atual. Basicamente, é recursivo.

Espero que ajude!

A propósito, no Nó v10.12.0, você pode usar a criação de caminhos recursivos, fornecendo-o como argumento adicional.

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

https://nodejs.org/api/fs.html#fs_fs_mkdirsync_path_options

Muitas respostas, mas aqui está uma solução sem recursão que funciona dividindo o caminho e construindo da esquerda para a direita novamente

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

Para aqueles preocupados com a compatibilidade do Windows com o Linux, basta substituir a barra com barra invertida dupla '\' nas duas ocorrências acima, mas TBH estamos falando sobre a linha de comando do nó fs not windows e a primeira é bastante tolerante e o código acima simplesmente funciona Windows e é mais uma solução completa entre plataformas.

const fs = require('fs');

try {
    fs.mkdirSync(path, { recursive: true });
} catch (error) {
    // this make script keep running, even when folder already exist
    console.log(error);
}

Uma maneira assíncrona de criar diretórios recursivamente:

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!')
})

Aqui está a minha versão imperativa do mkdirpfor nodejs.

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

Que tal essa abordagem:

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

Isso funciona para o caminho relativo.

Com base na resposta das dependências zero do montanhista , aqui está uma Typescriptvariante um pouco mais amigável para iniciantes , como um módulo:

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 next call to reduce
    }, initDir);
}

Tão limpo quanto isso :)

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

Como tive problemas com a opção recursiva do fs.mkdir, criei uma função que faz o seguinte:

1. Cria uma lista de todos os diretórios, começando com o diretório de destino final e trabalhando até o pai raiz.
2. Cria uma nova lista de diretórios necessários para a função mkdir funcionar

3. Faz com que cada diretório seja necessário, incluindo o 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 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 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();
       });
    }

Exec pode ser confuso no Windows. Existe uma solução mais "nodie". Fundamentalmente, você tem uma chamada recursiva para ver se existe um diretório e mergulhar no filho (se ele existir) ou criá-lo. Aqui está uma função que criará os filhos e chamará uma função quando terminar:

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

}

Esta versão funciona melhor no Windows do que a resposta principal, porque entende as duas /e path.seppara que as barras funcionem no Windows como deveriam. Oferece suporte a caminhos absolutos e relativos (relativos ao 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;
}