Node.js Ordner erstellen oder vorhandene verwenden

Ich habe bereits die Dokumentation von Node.js gelesen und es sei denn, ich habe etwas verpasst, es sagt nicht aus, was die Parameter insbesondere in bestimmten Operationen enthalten fs.mkdir(). Wie Sie in der Dokumentation sehen können, ist es nicht sehr viel.

Derzeit habe ich diesen Code, der versucht, einen Ordner zu erstellen oder stattdessen einen vorhandenen zu verwenden:

fs.mkdir(path,function(e){
    if(!e || (e && e.code === 'EEXIST')){
        //do something with contents
    } else {
        //debug
        console.log(e);
    }
});

Aber ich frage mich, ob dies der richtige Weg ist? Ist das Überprüfen des Codes EEXISTder richtige Weg, um festzustellen, dass der Ordner bereits vorhanden ist? Ich weiß, dass ich das tun kann, fs.stat()bevor ich das Verzeichnis erstelle, aber das wären bereits zwei Treffer für das Dateisystem.

Zweitens gibt es eine vollständige oder zumindest detailliertere Dokumentation von Node.js, die Details darüber enthält, welche Fehlerobjekte enthalten, welche Parameter bedeuten usw.

Ein guter Weg, dies zu tun, ist die Verwendung des Moduls mkdirp .

$ npm install mkdirp

Verwenden Sie diese Option, um eine Funktion auszuführen, für die das Verzeichnis erforderlich ist. Der Rückruf wird aufgerufen, nachdem der Pfad erstellt wurde oder wenn der Pfad bereits vorhanden war. Der Fehler errwird gesetzt, wenn mkdirp den Verzeichnispfad nicht erstellen konnte.

var mkdirp = require('mkdirp');
mkdirp('/tmp/some/path/foo', function(err) { 

    // path exists unless there was an error

});

Bearbeiten: Da diese Antwort sehr beliebt ist, habe ich sie aktualisiert, um aktuelle Praktiken widerzuspiegeln.

Knoten> = 10

Die neue { recursive: true }Option von Node's fsermöglicht dies jetzt nativ. Diese Option ahmt das Verhalten von UNIX nach mkdir -p. Es stellt rekursiv sicher, dass jeder Teil des Pfads vorhanden ist, und gibt keinen Fehler aus, wenn einer von ihnen dies tut.

(Hinweis: Es kann immer noch Fehler wie EPERModer EACCESSauslösen, also wickeln Sie es besser in ein, try {} catch (e) {}wenn Ihre Implementierung dafür anfällig ist.)

Synchrone Version.

fs.mkdirSync(dirpath, { recursive: true })

Asynchrone Version

await fs.promises.mkdir(dirpath, { recursive: true })

Ältere Knotenversionen

Mit a try {} catch (err) {}können Sie dies sehr elegant erreichen, ohne auf eine Rennbedingung zu stoßen.

Um eine Totzeit zwischen der Überprüfung der Existenz und der Erstellung des Verzeichnisses zu vermeiden, versuchen wir einfach, es direkt zu erstellen, und ignorieren den Fehler, falls dies der Fall ist EEXIST (Verzeichnis existiert bereits).

Wenn der Fehler jedoch nicht EEXISTvorliegt, sollten wir einen Fehler auslösen, da es sich möglicherweise um ein EPERModer handeltEACCES

function ensureDirSync (dirpath) {
  try {
    return fs.mkdirSync(dirpath)
  } catch (err) {
    if (err.code !== 'EEXIST') throw err
  }
}

Für mkdir -p-ähnlichen rekursive Verhalten, zum Beispiel ./a/b/c, würden Sie sie auf jedem Teil der dirpath nennen müssen, zum Beispiel ./a, ./a/b,.a/b/c

Wenn Sie einen schnell und schmutzigen Einzeiler wünschen, verwenden Sie diesen:

fs.existsSync("directory") || fs.mkdirSync("directory");

Die docs von node.js für werden fs.mkdirgrundsätzlich auf die Linux-Manpage für verschobenmkdir(2) . Dies zeigt an, dass dies EEXISTauch angezeigt wird, wenn der Pfad vorhanden ist, es sich jedoch nicht um ein Verzeichnis handelt, das bei dieser Route einen unangenehmen Eckfall erzeugt.

Sie können besser anrufen fs.stat , um festzustellen, ob der Pfad vorhanden ist und ob es sich um ein Verzeichnis in einem einzelnen Aufruf handelt. Für den Normalfall, in dem das Verzeichnis bereits vorhanden ist, handelt es sich nur um einen einzigen Dateisystem-Treffer.

Bei diesen fsModulmethoden handelt es sich um Thin Wrapper um die nativen C-APIs. Sie müssen daher die Manpages überprüfen, auf die in den Dokumenten von node.js verwiesen wird, um Einzelheiten zu erfahren.

Sie können dies verwenden:

if(!fs.existsSync("directory")){
    fs.mkdirSync("directory", 0766, function(err){
        if(err){
            console.log(err);
            // echo the result back
            response.send("ERROR! Can't make the directory! \n");
        }
    });
}

Ich schlage eine Lösung ohne Module vor (das Sammeln von Modulen wird aus Gründen der Wartbarkeit niemals empfohlen, insbesondere für kleine Funktionen, die in wenigen Zeilen geschrieben werden können ...):

LETZTES UPDATE :

In Version 10.12.0 implementieren NodeJS rekursive Optionen:

// Create recursive folder
fs.mkdir('my/new/folder/create', { recursive: true }, (err) => { if (err) throw err; });

UPDATE:

// Get modules node
const fs   = require('fs');
const path = require('path');

// Create 
function mkdirpath(dirPath)
{
    if(!fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK))
    {
        try
        {
            fs.mkdirSync(dirPath);
        }
        catch(e)
        {
            mkdirpath(path.dirname(dirPath));
            mkdirpath(dirPath);
        }
    }
}

// Create folder path
mkdirpath('my/new/folder/create');

Sie können auch fs-extra verwenden , das häufig verwendete Dateivorgänge bereitstellt.

Beispielcode:

var fs = require('fs-extra')

fs.mkdirs('/tmp/some/long/path/that/prob/doesnt/exist', function (err) {
  if (err) return console.error(err)
  console.log("success!")
})

fs.mkdirsSync('/tmp/another/path')

Dokumente hier: https://github.com/jprichardson/node-fs-extra#mkdirsdir-callback

Hier ist der ES6-Code, mit dem ich ein Verzeichnis erstelle (wenn es nicht existiert):

const fs = require('fs');
const path = require('path');

function createDirectory(directoryPath) {
  const directory = path.normalize(directoryPath);

  return new Promise((resolve, reject) => {
    fs.stat(directory, (error) => {
      if (error) {
        if (error.code === 'ENOENT') {
          fs.mkdir(directory, (error) => {
            if (error) {
              reject(error);
            } else {
              resolve(directory);
            }
          });
        } else {
          reject(error);
        }
      } else {
        resolve(directory);
      }
    });
  });
}

const directoryPath = `${__dirname}/test`;

createDirectory(directoryPath).then((path) => {
  console.log(`Successfully created directory: '${path}'`);
}).catch((error) => {
  console.log(`Problem creating directory: ${error.message}`)
});

Hinweis:

• Am Anfang der createDirectoryFunktion, ich den Weg zu garantieren normalisieren , dass der Pfad seperator Typ des Betriebssystems konsequent genutzt werden (zB dies wird sich C:\directory/testin C:\directory\test(unter Windows ist)
• fs.existsist veraltet , deshalb fs.statüberprüfe ich , ob das Verzeichnis bereits existiert
• Wenn ein Verzeichnis nicht vorhanden ist , wird der Fehlercode sein ENOENT( E rror NO ENT ry)
• Das Verzeichnis selbst wird mit erstellt fs.mkdir
• Ich bevorzuge die asynchrone Funktion fs.mkdirgegenüber dem blockierenden Gegenstück fs.mkdirSyncund aufgrund des Umbruchs Promisewird garantiert, dass der Pfad des Verzeichnisses erst zurückgegeben wird, nachdem das Verzeichnis erfolgreich erstellt wurde

Meiner Meinung nach sollten Sie die Dateisystem-Treffer beim Codieren in Javascript besser nicht zählen. Wenn Sie jedoch (1) stat& mkdirund (2) mkdirden Fehlercode überprüfen (oder verwerfen), sind beide Möglichkeiten die richtigen, um das zu tun, was Sie wollen.

Erstellen Sie ein dynamisches Namensverzeichnis für jeden Benutzer. Verwenden Sie diesen Code

***suppose email contain user mail address***

var filessystem = require('fs');
var dir = './public/uploads/'+email;

if (!filessystem.existsSync(dir)){
  filessystem.mkdirSync(dir);

}else
{
    console.log("Directory already exist");
}

All dies können Sie mit dem Dateisystemmodul tun.

const
  fs = require('fs'),
  dirPath = `path/to/dir`

// Check if directory exists.
fs.access(dirPath, fs.constants.F_OK, (err)=>{
  if (err){
    // Create directory if directory does not exist.
    fs.mkdir(dirPath, {recursive:true}, (err)=>{
      if (err) console.log(`Error creating directory: ${err}`)
      else console.log('Directory created successfully.')
    })
  }
  // Directory now exists.
})

Sie müssen wirklich nicht einmal überprüfen, ob das Verzeichnis vorhanden ist. Der folgende Code garantiert auch, dass das Verzeichnis entweder bereits vorhanden ist oder erstellt wurde.

const
  fs = require('fs'),
  dirPath = `path/to/dir`

// Create directory if directory does not exist.
fs.mkdir(dirPath, {recursive:true}, (err)=>{
  if (err) console.log(`Error creating directory: ${err}`)
  // Directory now exists.
})

Raugarals Antwort, aber mit -p-Funktionalität. Hässlich, aber es funktioniert:

function mkdirp(dir) {
    let dirs = dir.split(/\\/).filter(asdf => !asdf.match(/^\s*$/))
    let fullpath = ''

    // Production directory will begin \\, test is on my local drive.
    if (dirs[0].match(/C:/i)) {
        fullpath = dirs[0] + '\\'
    }
    else {
        fullpath = '\\\\' + dirs[0] + '\\'
    }

    // Start from root directory + 1, build out one level at a time.
    dirs.slice(1).map(asdf => {
        fullpath += asdf + '\\'
        if (!fs.existsSync(fullpath)) {
            fs.mkdirSync(fullpath)
        }
    })
}//mkdirp

Eine neuere Alternative zu Teemu Ikonens Antwort , die sehr einfach und leicht lesbar ist, ist die Verwendung der ensureDirMethode desfs-extra Paketmethode.

Es kann nicht nur als offensichtlicher Ersatz für das eingebaute fsModul verwendet werden, sondern verfügt neben den Funktionen des Moduls auch über viele andere Funktionenfs Pakets .

Die ensureDirMethode stellt, wie der Name schon sagt, sicher, dass das Verzeichnis vorhanden ist. Wenn die Verzeichnisstruktur nicht vorhanden ist, wird sie erstellt. Mögenmkdir -p . Nicht nur der Endordner, sondern der gesamte Pfad wird erstellt, falls noch nicht vorhanden.

Die oben angegebene ist die asyncVersion davon. Es gibt auch eine synchrone Methode, um dies in Form der ensureDirSyncMethode durchzuführen .

Die Antwort von @ Liberateur oben hat bei mir nicht funktioniert (Node v8.10.0). Kleine Modifikationen haben den Trick gemacht, aber ich bin mir nicht sicher, ob dies der richtige Weg ist. Bitte vorschlagen.

// Get modules node
const fs   = require('fs');
const path = require('path');

// Create
function mkdirpath(dirPath)
{
    try {
        fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
    }
    catch(err) {
        try
        {
            fs.mkdirSync(dirPath);
        }
        catch(e)
        {
            mkdirpath(path.dirname(dirPath));
            mkdirpath(dirPath);
        }
    }
}

// Create folder path
mkdirpath('my/new/folder/create');