Jak utworzyć pełną ścieżkę za pomocą narzędzia fs.mkdirSync w węźle?

Próbuję utworzyć pełną ścieżkę, jeśli nie istnieje.

Kod wygląda następująco:

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

Ten kod działa świetnie, o ile istnieje tylko jeden podkatalog (newDest, taki jak „dir1”), jednak gdy istnieje ścieżka do katalogu, taka jak („dir1 / dir2”), kończy się niepowodzeniem z błędem: ENOENT, brak takiego pliku lub katalogu

Chciałbym móc utworzyć pełną ścieżkę z jak najmniejszą liczbą wierszy kodu.

Czytałem, że na fs jest opcja rekurencyjna i wypróbowałem to w ten sposób

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

Wydaje mi się, że rekurencyjne tworzenie katalogu, który nie istnieje, powinno być takie proste. Czy coś mi brakuje, czy muszę przeanalizować ścieżkę i sprawdzić każdy katalog i utworzyć go, jeśli jeszcze nie istnieje?

Jestem całkiem nowy w Node. Może używam starej wersji FS?

Jedną z opcji jest użycie modułu shelljs

npm zainstaluj shelljs

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

Z tej strony:

Dostępne opcje:

p: pełna ścieżka (w razie potrzeby utworzy katalogi pośrednie)

Jak zauważyli inni, istnieją inne, bardziej ukierunkowane moduły. Ale poza mkdirp ma mnóstwo innych użytecznych operacji powłoki (takich jak which, grep itp ...) i działa w systemie Windows i * nix

Edytować

Wersja NodeJS 10.12.0dodała natywną obsługę obu mkdiri mkdirSynctworzenie katalogu rekurencyjnego z następującą recursive: trueopcją:

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

A jeśli wolisz fs Promises API, możesz pisać

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

Oryginalna odpowiedź

Twórz katalogi rekurencyjnie, jeśli nie istnieją! ( Zero zależności )

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

Stosowanie

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

Próbny

Spróbuj!

Wyjaśnienia

• [UPDATE] Błędy Ta platforma uchwyty rozwiązanie specyficzne jak EISDIRdla Mac i EPERMi EACCESdla Windows. Dziękuję wszystkim komentarzom zgłaszającym @PediT., @JohnQ, @ deed02392, @robyoder i @Almenon.
• To rozwiązanie obsługuje zarówno ścieżki względne, jak i bezwzględne . Dzięki komentarzowi @john.
• W przypadku ścieżek względnych katalogi docelowe zostaną utworzone (rozwiązane) w bieżącym katalogu roboczym. Aby rozwiązać je w odniesieniu do bieżącego katalogu skryptowego, pass {isRelativeToScript: true}.
• Używanie path.sepi path.resolve(), a nie tylko /konkatenacja, w celu uniknięcia problemów między platformami.
• Używanie fs.mkdirSynci obsługa błędu za pomocą try/catchif zgłoszonego w celu obsługi warunków wyścigu: inny proces może dodać plik między wywołaniami do fs.existsSync()i fs.mkdirSync()i powoduje wyjątek.
  • Innym sposobem na osiągnięcie tego może być sprawdzenie, czy plik istnieje, a następnie utworzenie go, tj if (!fs.existsSync(curDir) fs.mkdirSync(curDir);. Ale jest to anty-wzorzec, który pozostawia kod podatny na warunki wyścigu. Podziękowania dla @GershomMaes za komentarz dotyczący sprawdzenia istnienia katalogu.
• Wymaga Node v6 i nowszych do obsługi destrukturyzacji. (Jeśli masz problemy z wdrożeniem tego rozwiązania w starszych wersjach Node, po prostu zostaw komentarz)

Bardziej niezawodną odpowiedzią jest użycie mkdirp .

var mkdirp = require('mkdirp');

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

Następnie kontynuuj zapisywanie pliku w pełnej ścieżce za pomocą:

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

fs-extra dodaje metody systemu plików, które nie są zawarte w natywnym module fs. To kropla w zastępstwie fs.

zainstalować fs-extra

$ npm install --save fs-extra

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

Dostępne są opcje synchronizacji i asynchronizacji.

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

Korzystając z redukuj, możemy sprawdzić, czy każda ścieżka istnieje i stworzyć ją w razie potrzeby, również w ten sposób myślę, że jest łatwiejsza do naśladowania. Edytowane, dzięki @Arvin, powinniśmy użyć path.sep, aby uzyskać właściwy separator segmentów ścieżki specyficzny dla platformy.

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

Ta funkcja została dodana do node.js w wersji 10.12.0, więc jest to tak proste, jak przekazanie opcji {recursive: true}jako drugiego argumentu do fs.mkdir()wywołania. Zobacz przykład w oficjalnych dokumentach .

Nie ma potrzeby stosowania zewnętrznych modułów ani własnej implementacji.

Wiem, że to stare pytanie, ale nodejs v10.12.0 obsługuje to teraz natywnie z recursiveopcją ustawioną na 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;
});

Teraz z NodeJS> = 10.12.0możesz używać fs.mkdirSync(path, { recursive: true }) fs.mkdirSync

Przykład dla systemu Windows (bez dodatkowych zależności i obsługi błędów)

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

Możesz po prostu rekurencyjnie sprawdzić, czy folder istnieje lub nie ma w ścieżce, i sprawić, by folder nie był obecny. ( BRAK BIBLIOTEKI ZEWNĘTRZNEJ )

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

Możesz użyć następnej funkcji

const recursiveUpload = (path: string) => {const path = path.split ("/")

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

  fs.mkdirSync(fullPath)

  return fullPath
}

Więc co to robi:

1. Utwórz pathszmienną, w której przechowuje każdą ścieżkę samodzielnie jako element tablicy.
2. Dodaje „/” na końcu każdego elementu tablicy.
3. Marki na cykl:
   1. Tworzy katalog z konkatenacji elementów tablicy, których indeksy są od 0 do bieżącej iteracji. Zasadniczo jest rekurencyjny.

Mam nadzieję, że to pomoże!

Nawiasem mówiąc, w Node 10.12.0 można użyć rekurencyjnego tworzenia ścieżek, podając je jako dodatkowy argument.

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

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

Ta wersja działa lepiej w systemie Windows niż najlepsza odpowiedź, ponieważ rozumie oba, /a path.sepukośniki działają w systemie Windows tak, jak powinny. Obsługuje ścieżki bezwzględne i względne (względem 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;
}