Wie erstelle ich einen vollständigen Pfad mit fs.mkdirSync des Knotens?

Ich versuche, einen vollständigen Pfad zu erstellen, wenn er nicht vorhanden ist.

Der Code sieht folgendermaßen aus:

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

Dieser Code funktioniert hervorragend, solange es nur ein Unterverzeichnis gibt (ein newDest wie 'dir1'). Wenn es jedoch einen Verzeichnispfad wie ('dir1 / dir2') gibt, schlägt er mit Fehler: ENOENT fehl, keine solche Datei oder kein solches Verzeichnis

Ich möchte in der Lage sein, den vollständigen Pfad mit so wenigen Codezeilen wie nötig zu erstellen.

Ich habe gelesen, dass es eine rekursive Option für fs gibt und habe es so versucht

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

Ich denke, es sollte so einfach sein, rekursiv ein Verzeichnis zu erstellen, das es nicht gibt. Fehlt mir etwas oder muss ich den Pfad analysieren, jedes Verzeichnis überprüfen und erstellen, falls es noch nicht vorhanden ist?

Ich bin ziemlich neu bei Node. Vielleicht verwende ich eine alte Version von FS?

Eine Möglichkeit ist die Verwendung des ShellJS-Moduls

npm installiere shelljs

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

Von dieser Seite:

Verfügbare Optionen:

p: vollständiger Pfad (erstellt bei Bedarf Zwischenverzeichnisse)

Wie andere angemerkt haben, gibt es andere fokussiertere Module. Außerhalb von mkdirp gibt es jedoch unzählige andere nützliche Shell-Operationen (wie welche, grep usw.) und es funktioniert unter Windows und * nix

Bearbeiten

Die NodeJS-Version 10.12.0hat eine native Unterstützung für beide hinzugefügt mkdirund mkdirSynczum rekursiven Erstellen eines Verzeichnisses mit recursive: trueder folgenden Option:

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

Und wenn Sie es vorziehen fs Promises API, können Sie schreiben

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

Ursprüngliche Antwort

Erstellen Sie Verzeichnisse rekursiv, wenn sie nicht vorhanden sind! ( Null Abhängigkeiten )

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

Verwendung

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

Versuch es!

Erklärungen

• [UPDATE] Diese Lösung Griffe plattformspezifische Fehler wie EISDIRfür Mac und EPERMund EACCESfür Windows. Vielen Dank an alle Berichtskommentare von @PediT., @JohnQ, @ deed02392, @robyoder und @Almenon.
• Diese Lösung verarbeitet sowohl relative als auch absolute Pfade. Danke an @john Kommentar.
• Bei relativen Pfaden werden Zielverzeichnisse im aktuellen Arbeitsverzeichnis erstellt (aufgelöst). Übergeben Sie, um sie relativ zum aktuellen Skriptverzeichnis aufzulösen {isRelativeToScript: true}.
• Verwenden path.sepund path.resolve()nicht nur /Verketten, um plattformübergreifende Probleme zu vermeiden.
• Verwenden fs.mkdirSyncund Behandeln des Fehlers mit, try/catchwenn er ausgelöst wird, um die Rennbedingungen zu behandeln: Ein anderer Prozess kann die Datei zwischen den Aufrufen von fs.existsSync()und hinzufügen fs.mkdirSync()und eine Ausnahme verursachen.
  • Der andere Weg, dies zu erreichen, könnte darin bestehen, zu überprüfen, ob eine Datei vorhanden ist, und sie dann zu erstellen, d if (!fs.existsSync(curDir) fs.mkdirSync(curDir);. H. Dies ist jedoch ein Anti-Pattern, das den Code für Rennbedingungen anfällig macht. Dank @GershomMaes Kommentar zur Verzeichnis-Existenzprüfung.
• Benötigt Node v6 und neuer, um die Destrukturierung zu unterstützen. (Wenn Sie Probleme bei der Implementierung dieser Lösung mit alten Node-Versionen haben, hinterlassen Sie mir einfach einen Kommentar.)

Eine robustere Antwort ist die Verwendung von mkdirp .

var mkdirp = require('mkdirp');

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

Schreiben Sie dann die Datei in den vollständigen Pfad mit:

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

fs-extra fügt Dateisystemmethoden hinzu, die nicht im nativen fs-Modul enthalten sind. Es ist ein Rückgang des Ersatzes für fs.

Installieren fs-extra

$ npm install --save fs-extra

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

Es gibt Synchronisierungs- und Asynchronisierungsoptionen.

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

Mit reduzieren können wir überprüfen, ob jeder Pfad vorhanden ist, und ihn bei Bedarf erstellen. Auch auf diese Weise ist es meiner Meinung nach einfacher, ihm zu folgen. Dank @Arvin bearbeitet, sollten wir path.sep verwenden, um das richtige plattformspezifische Trennzeichen für Pfadsegmente zu erhalten.

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

Diese Funktion wurde in Version 10.12.0 zu node.js hinzugefügt, sodass es so einfach ist, eine Option {recursive: true}als zweites Argument an den fs.mkdir()Aufruf zu übergeben. Siehe das Beispiel in den offiziellen Dokumenten .

Keine Notwendigkeit für externe Module oder Ihre eigene Implementierung.

Ich weiß, dass dies eine alte Frage ist, aber nodejs v10.12.0 unterstützt dies jetzt nativ mit der recursiveOption 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;
});

Jetzt mit NodeJS> = 10.12.0, können Sie fs.mkdirSync(path, { recursive: true }) fs.mkdirSync

Beispiel für Windows (keine zusätzlichen Abhängigkeiten und Fehlerbehandlung)

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

Sie können einfach rekursiv überprüfen, ob ein Ordner vorhanden ist oder nicht, und den Ordner erstellen, während Sie prüfen, ob er nicht vorhanden ist. ( KEINE EXTERNE BIBLIOTHEK )

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

Sie können die nächste Funktion verwenden

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

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

  fs.mkdirSync(fullPath)

  return fullPath
}

Also, was es tut:

1. Erstellen Sie eine pathsVariable, in der jeder Pfad für sich als Element des Arrays gespeichert wird.
2. Fügt am Ende jedes Elements im Array "/" hinzu.
3. Macht für den Zyklus:
   1. Erstellt ein Verzeichnis aus der Verkettung von Array-Elementen, deren Indizes von 0 bis zur aktuellen Iteration reichen. Grundsätzlich ist es rekursiv.

Hoffentlich hilft das!

Übrigens können Sie in Node v10.12.0 die rekursive Pfaderstellung verwenden, indem Sie sie als zusätzliches Argument angeben.

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

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

Diese Version funktioniert unter Windows besser als die Top-Antwort, da sie beide versteht /und path.sepSchrägstriche unter Windows so funktionieren, wie sie sollten. Unterstützt absolute und relative Pfade (relativ zu 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;
}