Node.js crea una cartella o usa esistente

Ho già letto la documentazione di Node.js e, se non ho perso qualcosa, non dice cosa contengono i parametri in determinate operazioni, in particolare fs.mkdir(). Come puoi vedere nella documentazione, non è molto.

Attualmente, ho questo codice, che tenta di creare una cartella o utilizzare invece una esistente:

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

Ma mi chiedo sia questo il modo giusto di farlo? Controllare il codice è EEXISTil modo giusto per sapere che la cartella esiste già? So che posso fare fs.stat()prima di creare la directory, ma sarebbero già due hit per il filesystem.

In secondo luogo, esiste una documentazione completa o almeno più dettagliata di Node.js che contiene dettagli su cosa contengono gli oggetti di errore, quali parametri indicano ecc.

Un buon modo per farlo è usare il modulo mkdirp .

$ npm install mkdirp

Usalo per eseguire la funzione che richiede la directory. Il callback viene chiamato dopo la creazione del percorso o se il percorso esiste già. L'errore errviene impostato se mkdirp non è riuscito a creare il percorso della directory.

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

    // path exists unless there was an error

});

Modifica: poiché questa risposta è molto popolare, l'ho aggiornata per riflettere le pratiche aggiornate.

Nodo> = 10

La nuova { recursive: true }opzione di Node fsora lo consente in modo nativo. Questa opzione imita il comportamento di UNIX mkdir -p. Si assicurerà in modo ricorsivo che ogni parte del percorso esista e non genererà un errore se ce ne sono.

(Nota: potrebbe comunque generare errori come EPERMo EACCESS, quindi meglio ancora racchiuderlo in try {} catch (e) {}se l'implementazione è suscettibile ad essa.)

Versione sincrona.

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

Versione asincrona

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

Versioni precedenti del nodo

Usando a try {} catch (err) {}, puoi ottenerlo con garbo senza incontrare una condizione di razza.

Al fine di prevenire i tempi morti tra il controllo dell'esistenza e la creazione della directory, proviamo semplicemente a crearla e ignorare l'errore se presente EEXIST(directory già esistente).

Se l'errore non è EEXIST, tuttavia, dovremmo generare un errore, perché potremmo avere a che fare con qualcosa come un EPERMoEACCES

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

Per mkdir -p-come comportamento ricorsivo, per esempio ./a/b/c, che avrebbe dovuto chiamare in ogni parte del dirpath, ad esempio ./a, ./a/b,.a/b/c

Se si desidera un rivestimento rapido e sporco, utilizzare questo:

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

I documenti node.js per fs.mkdirsostanzialmente rimandano alla pagina man di Linux per mkdir(2). Ciò indica che EEXISTverrà indicato anche se il percorso esiste ma non è una directory che crea un caso angolare imbarazzante se segui questa strada.

Potrebbe essere meglio chiamare fs.statche ti dirà se il percorso esiste e se si tratta di una directory in una singola chiamata. Per (quello che presumo sia) il caso normale in cui la directory esiste già, è solo un singolo hit del filesystem.

Questi fsmetodi del modulo sono wrapper sottili attorno alle API C native, quindi è necessario controllare le pagine man a cui si fa riferimento nei documenti node.js per i dettagli.

Puoi usare questo:

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

Propongo una soluzione senza moduli (accumulare moduli non è mai raccomandato per manutenibilità soprattutto per le piccole funzioni che possono essere scritte in poche righe ...):

ULTIMO AGGIORNAMENTO :

Nella v10.12.0, le opzioni ricorsive di impletement di NodeJS:

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

AGGIORNARE :

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

Puoi anche usare fs-extra , che fornisce molte operazioni sui file usate di frequente.

Codice di esempio:

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

documenti qui: https://github.com/jprichardson/node-fs-extra#mkdirsdir-callback

Ecco il codice ES6 che utilizzo per creare una directory (quando non esiste):

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

Nota:

• All'inizio della createDirectoryfunzione, normalizzo il percorso per garantire che il tipo di separatore di percorso del sistema operativo verrà utilizzato in modo coerente (ad esempio questo si trasformerà C:\directory/testin C:\directory\test(quando si è su Windows)
• fs.existsè deprecato , ecco perché uso fs.statper verificare se la directory esiste già
• Se non esiste una directory, il codice di errore sarà ENOENT( E rror NO ENT ry)
• La directory stessa verrà creata utilizzando fs.mkdir
• Preferisco la funzione asincrona fs.mkdirrispetto alla sua controparte bloccante fs.mkdirSynce grazie al wrapping Promisesarà garantito che il percorso della directory verrà restituito solo dopo che la directory è stata creata correttamente

A mio parere, è meglio non contare gli hit del filesystem mentre si codifica in Javascript. Tuttavia, (1) stat& mkdire (2) mkdire controllare (o scartare) il codice di errore, entrambi i modi sono i modi giusti per fare quello che vuoi.

crea una directory di nomi dinamici per ogni utente ... usa questo codice

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

Puoi fare tutto questo con il modulo File System.

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

Non hai nemmeno bisogno di controllare se la directory esiste. Il codice seguente garantisce inoltre che la directory sia già esistente o creata.

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

La risposta di Raugaral ma con funzionalità -p. Brutto, ma funziona:

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

Proprio come una nuova alternativa alla risposta di Teemu Ikonen , che è molto semplice e facilmente leggibile, è usare il ensureDirmetodo del fs-extrapacchetto.

Non può essere utilizzato solo come sostituto palese del fsmodulo integrato, ma ha anche molte altre funzionalità oltre alle funzionalità del fspacchetto.

Il ensureDirmetodo, come suggerisce il nome, garantisce l'esistenza della directory. Se la struttura della directory non esiste, viene creata. Come mkdir -p. Non solo la cartella finale, ma l'intero percorso viene creato se non esiste già.

quella fornita sopra è la asyncversione di esso. Ha anche un metodo sincrono per eseguire ciò nella forma del ensureDirSyncmetodo.

La risposta di @ Liberateur sopra non ha funzionato per me (Nodo v8.10.0). Poche modifiche hanno funzionato, ma non sono sicuro che sia la strada giusta. Per favore, suggerisci

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