Node.js crée un dossier ou utilise des

J'ai déjà lu la documentation de Node.js et, sauf si j'ai manqué quelque chose, elle ne dit pas ce que les paramètres contiennent dans certaines opérations, notamment fs.mkdir(). Comme vous pouvez le voir dans la documentation, ce n'est pas beaucoup.

Actuellement, j'ai ce code, qui essaie de créer un dossier ou d'en utiliser un existant à la place:

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

Mais je me demande si c'est la bonne façon de le faire? La vérification du code est-elle EEXISTla bonne façon de savoir que le dossier existe déjà? Je sais que je peux faire fs.stat()avant de créer le répertoire, mais ce serait déjà deux coups au système de fichiers.

Deuxièmement, existe-t-il une documentation complète ou au moins plus détaillée de Node.js qui contient des détails sur ce que contiennent les objets d'erreur, quels paramètres signifient, etc.

Une bonne façon de faire est d'utiliser le module mkdirp .

$ npm install mkdirp

Utilisez-le pour exécuter la fonction qui nécessite le répertoire. Le rappel est appelé après la création du chemin ou si le chemin existe déjà. L'erreur errest définie si mkdirp n'a pas réussi à créer le chemin du répertoire.

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

    // path exists unless there was an error

});

Edit: Parce que cette réponse est très populaire, je l'ai mise à jour pour refléter les pratiques à jour.

Nœud> = 10

La nouvelle { recursive: true }option de Node le fspermet désormais de manière native. Cette option imite le comportement d'UNIX mkdir -p. Il s'assurera de manière récursive que chaque partie du chemin existe et ne lèvera pas d'erreur si l'une d'entre elles le fait.

(Remarque: il peut toujours générer des erreurs telles que EPERMou EACCESS, il vaut donc mieux l'envelopper dans un try {} catch (e) {}si votre implémentation y est sensible.)

Version synchrone.

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

Version asynchrone

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

Anciennes versions de Node

En utilisant a try {} catch (err) {}, vous pouvez y parvenir très gracieusement sans rencontrer de condition de concurrence.

Afin d'éviter un temps mort entre la vérification de l'existence et la création du répertoire, nous essayons simplement de le créer directement et de ne pas tenir compte de l'erreur si elle existe EEXIST(le répertoire existe déjà).

Si l'erreur n'est pas EEXIST, cependant, nous devrions lancer une erreur, car nous pourrions avoir affaire à quelque chose comme un EPERMouEACCES

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

Pour mkdir -p-comme le comportement récursif, par exemple ./a/b/c, il faudrait l' appeler sur chaque partie du dirpath, par exemple ./a, ./a/b,.a/b/c

Si vous voulez une doublure rapide et sale, utilisez ceci:

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

La documentation node.js pour fs.mkdirse réfère essentiellement à la page de manuel Linux pour mkdir(2). Cela indique que cela EEXISTsera également indiqué si le chemin existe mais n'est pas un répertoire qui crée un cas de coin gênant si vous suivez cette route.

Vous feriez peut-être mieux d'appeler fs.statqui vous dira si le chemin existe et s'il s'agit d'un répertoire en un seul appel. Pour (ce que je suppose est) le cas normal où le répertoire existe déjà, ce n'est qu'un seul coup de système de fichiers.

Ces fsméthodes de module sont des enveloppes minces autour des API C natives, vous devez donc consulter les pages de manuel référencées dans la documentation node.js pour plus de détails.

Vous pouvez utiliser ceci:

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

Je propose une solution sans modules (accumuler des modules n'est jamais recommandé pour la maintenabilité surtout pour les petites fonctions qui peuvent s'écrire en quelques lignes ...):

DERNIÈRE MISE À JOUR :

Dans la v10.12.0, NodeJS implémente les options récursives:

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

METTRE À JOUR :

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

Vous pouvez également utiliser fs-extra , qui fournit de nombreuses opérations de fichiers fréquemment utilisées.

Exemple de code:

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

docs ici: https://github.com/jprichardson/node-fs-extra#mkdirsdir-callback

Voici le code ES6 que j'utilise pour créer un répertoire (quand il n'existe pas):

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

Remarque:

• Au début de la createDirectoryfonction, je normalise le chemin pour garantir que le type de séparateur de chemin du système d'exploitation sera utilisé de manière cohérente (par exemple, cela se transformera C:\directory/testen C:\directory\test(sous Windows)
• fs.existsest obsolète , c'est pourquoi j'utilise fs.statpour vérifier si le répertoire existe déjà
• Si un répertoire n'existe pas, le code d'erreur sera ENOENT( E rror NO ENT ry)
• Le répertoire lui-même sera créé en utilisant fs.mkdir
• Je préfère la fonction asynchrone fs.mkdirà son homologue bloquant fs.mkdirSyncet en raison de l'emballage, Promiseil sera garanti que le chemin du répertoire ne sera retourné qu'une fois le répertoire créé avec succès

Vous feriez mieux de ne pas compter les hits du système de fichiers pendant que vous codez en Javascript, à mon avis. Cependant, (1) stat& mkdiret (2) mkdiret vérifiez (ou supprimez) le code d'erreur, les deux méthodes sont bonnes pour faire ce que vous voulez.

créer un répertoire de noms dynamiques pour chaque utilisateur ... utiliser ce 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");
}

Vous pouvez faire tout cela avec le module 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.
})

Vous n'avez même pas besoin de vérifier si le répertoire existe. Le code suivant garantit également que le répertoire existe déjà ou est créé.

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

Réponse de Raugaral mais avec la fonctionnalité -p. Moche, mais ça marche:

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

Tout comme une nouvelle alternative à la réponse de Teemu Ikonen , qui est très simple et facilement lisible, est d'utiliser la ensureDirméthode dufs-extra package.

Il peut non seulement être utilisé comme un remplacement flagrant du fsmodule intégré, mais possède également de nombreuses autres fonctionnalités en plus des fonctionnalités dufs package.

La ensureDirméthode, comme son nom l'indique, garantit que le répertoire existe. Si la structure de répertoires n'existe pas, elle est créée. Commemkdir -p . Pas seulement le dossier final, mais le chemin complet est créé s'il n'existe pas déjà.

celui fourni ci-dessus en est la asyncversion. Il a également une méthode synchrone pour effectuer cela sous la forme de la ensureDirSyncméthode.

La réponse de @ Liberateur ci - dessus n'a pas fonctionné pour moi (Node v8.10.0). Une petite modification a fait l'affaire mais je ne suis pas sûr que ce soit une bonne façon. Veuillez suggérer.

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