노드의 fs.mkdirSync로 전체 경로를 만드는 방법은 무엇입니까?

존재하지 않는 경우 전체 경로를 만들려고합니다.

코드는 다음과 같습니다.

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

이 코드는 하나의 서브 디렉토리 ( 'dir1'과 같은 newDest) 만있는 한 훌륭하게 작동하지만 ( 'dir1 / dir2')와 같은 디렉토리 경로가 있으면 실패합니다. 오류 . ENOENT, 해당 파일 또는 디렉토리 없음

필요에 따라 몇 줄의 코드로 전체 경로를 만들 수 있기를 원합니다.

나는 fs에 재귀 적 옵션이 있으며 이것을 다음과 같이 시도했다.

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

존재하지 않는 디렉토리를 재귀 적으로 만드는 것이 간단해야한다고 생각합니다. 내가 빠진 것이거나 경로를 구문 분석하고 각 디렉토리를 확인하여 존재하지 않는 경우 생성해야합니까?

저는 Node를 처음 접했습니다. 이전 버전의 FS를 사용하고 있습니까?

하나의 옵션은 shelljs 모듈 을 사용하는 것입니다

npm 설치 shelljs

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

해당 페이지에서 :

사용 가능한 옵션 :

p : 전체 경로 (필요한 경우 중간 디렉토리 작성)

다른 사람들이 지적했듯이, 더 집중된 다른 모듈이 있습니다. 그러나 mkdirp 외부에는 다른 유용한 쉘 작업 (예 : grep 등)이 있으며 Windows 및 * nix에서 작동합니다.

편집하다

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

데모

시도 해봐!

설명

• [업데이트] 이 솔루션은 EISDIRMac EPERM및EACCES Windows 용. @PediT., @JohnQ, @ deed02392, @robyoder 및 @Almenon의 모든 의견에 감사드립니다.
• 이 솔루션은 상대 및 절대를 모두 처리합니다. 경로 경로를 합니다. @john의 의견에 감사드립니다.
• 상대 경로의 경우, 현재 작업중인 디렉토리에 대상 디렉토리가 작성 (해결)됩니다. 현재 스크립트 디렉토리를 기준으로 해결하려면 다음을 전달하십시오.{isRelativeToScript: true} .
• 사용 path.sep및 path.resolve()뿐만 아니라, /크로스 플랫폼 문제를 방지하기 위해 연결.
• 사용 fs.mkdirSync과 함께 오류 처리 try/catch경쟁 조건을 처리하기 위해 발생하는 경우를 : 다른 프로세스로 호출 사이에 파일을 추가 할 수 있습니다 fs.existsSync()및 fs.mkdirSync()예외가 발생합니다.
  • 이를 달성하는 다른 방법은 파일이 존재하는지 확인한 다음 파일을 만드는 것 if (!fs.existsSync(curDir) fs.mkdirSync(curDir);입니다. 그러나 이것은 코드를 경쟁 조건에 취약하게 만드는 반 패턴입니다. @GershomMaes 덕분에 디렉토리 존재 점검에 대한 의견이 있습니다.
• 디스트 럭처링 을 지원하려면 Node v6 이상이 필요합니다 . (이전 노드 버전 으로이 솔루션을 구현하는 데 문제가 있으면 의견을 남겨주세요)

더 강력한 대답은 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'....

fs-extra는 기본 fs 모듈에 포함되지 않은 파일 시스템 메소드를 추가합니다. fs를 대체하는 것입니다.

설치 fs-extra

$ npm install --save fs-extra

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

동기화 및 비동기 옵션이 있습니다.

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

reduce를 사용하면 각 경로가 존재하는지 확인하고 필요한 경우 만들 수 있으며이 방법을 사용하면 더 쉽게 따라갈 수 있습니다. @Arvin 덕분에 path.sep를 사용하여 적절한 플랫폼 별 경로 세그먼트 구분 기호를 가져와야합니다.

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

이 기능은 버전 10.12.0에서 node.js에 추가되었으므로 호출에 {recursive: true}두 번째 인수만큼 옵션 을 전달하는 것만 큼 쉽습니다 fs.mkdir(). 공식 문서 의 예를 참조하십시오 .

외부 모듈이나 자체 구현이 필요하지 않습니다.

나는 이것이 오래된 질문이라는 것을 알고 있지만 nodejs v10.12.0은 이제 recursive옵션을 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;
});

이제 NodeJS와> = 10.12.0, 당신은 사용할 수 있습니다 fs.mkdirSync(path, { recursive: true }) fs.mkdirSync을

Windows의 예 (추가 종속성 및 오류 처리 없음)

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

단순히 경로에 폴더가 있는지 재귀 적으로 확인하고 존재하지 않는지 확인하면서 폴더를 만들 수 있습니다. ( 외부 라이브러리 없음 )

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

다음 기능을 사용할 수 있습니다

const recursiveUpload = (경로 : 문자열) => {const 경로 = path.split ( "/")

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

  fs.mkdirSync(fullPath)

  return fullPath
}

그것이하는 일 :

1. paths변수를 작성 하여 모든 경로를 자체적으로 배열의 요소로 저장합니다.
2. 배열의 각 요소 끝에 "/"를 추가합니다.
3. 사이클을 만듭니다.
   1. 인덱스가 0부터 현재 반복까지 인 배열 요소의 연결에서 디렉토리를 작성합니다. 기본적으로 재귀 적입니다.

희망이 도움이됩니다!

그런데 Node v10.12.0에서는 재귀 경로 생성을 추가 인수로 사용하여 사용할 수 있습니다.

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

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

답변이 너무 많지만 경로를 분할 한 다음 왼쪽에서 오른쪽으로 다시 빌드하여 작동하는 재귀없는 솔루션이 있습니다.

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

Windows 대 Linux 호환성에 관심이있는 사람들은 위의 두 가지 경우에 슬래시를 이중 백 슬래시 '\'로 간단히 바꾸십시오. 그러나 TBH 우리는 노드 fs에 대해 이야기하지 않습니다 .Windows 명령 줄이며 전자는 꽤 용서하며 위의 코드는 간단하게 작동합니다. Windows는 더 완벽한 솔루션 크로스 플랫폼입니다.

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

디렉토리를 재귀 적으로 생성하는 비동기 방식 :

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

다음 mkdirp은 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);
        }
    }
}

이 방법은 어떻습니까?

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

이것은 상대 경로에서 작동합니다.

mouneer의 제로 의존성 답변을 바탕 Typescript으로, 모듈로서 초보자에게 친숙한 변형이 있습니다.

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

이만큼 깨끗합니다 :)

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

fs.mkdir의 재귀 옵션에 문제가 있었으므로 다음을 수행하는 함수를 만들었습니다.

1. 최종 대상 디렉토리부터 루트 상위까지 모든 디렉토리 목록을 작성합니다.
2. mkdir 함수가 작동하는 데 필요한 디렉토리의 새 목록을 작성합니다.

3. 최종 디렉토리를 포함하여 필요한 각 디렉토리를 만듭니다.

   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은 Windows에서 지저분해질 수 있습니다. 더 "노디"솔루션이 있습니다. 기본적으로 디렉토리가 존재하는지 확인하고 하위 디렉토리가 있거나 하위 디렉토리가 있는지 확인하기 위해 재귀 호출이 있습니다. 다음은 자식을 만들고 완료되면 함수를 호출하는 함수입니다.

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

}

이 모두를 이해하기 때문에이 버전은 최고 응답보다 윈도우에서 더 잘 작동 /하고 path.sep그래서 슬래시들이 정상적으로 윈도우에서 작동하는지. 절대 및 상대 경로를 지원합니다 (에 상대적 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;
}