Comment créer un répertoire s'il n'existe pas à l'aide de Node.js?

Pas, pour de multiples raisons.

1. La path module ne dispose pas d'un exists/existsSync méthode. C'est dans le fs module. (Peut-être vous avez juste fait une faute de frappe dans votre question?)

2. Les docs explicitement décourager l'utilisation de exists.

   fs.exists() est un anachronisme et n'existe que pour des raisons historiques. Il ne devrait jamais être une raison pour l'utiliser dans votre propre code.

   En particulier, de vérifier si un fichier existe avant l'ouverture, il est un anti-modèle qui vous laisse vulnérables à des conditions de course: un autre processus peut supprimer le fichier entre les appels à fs.exists() et fs.open(). Il suffit d'ouvrir le fichier et de gérer l'erreur quand il n'y est pas.

   Puisque nous parlons d'un répertoire plutôt que d'un fichier, ce conseil implique que vous devriez juste inconditionnellement appel mkdir et ignorer EEXIST.

3. En général, Vous devriez éviter l' *Sync méthodes. Ils sont de blocage, ce qui ne signifie absolument rien d'autre dans votre programme peut se produire pendant que vous allez sur le disque. C'est une opération très coûteuse, et le temps qu'il faut brise le cœur hypothèse de nœud de boucle d'évènements.

   L' *Sync méthodes sont généralement d'amende dans le seul but rapide de scripts (ceux qui font une chose et puis la sortie), mais ne devrait jamais être utilisé lorsque vous êtes en train de rédiger un serveur: votre serveur sera pas en mesure de répondre à toute personne pour toute la durée de l'I/O demandes. Si plusieurs demandes de clients nécessitent des opérations d'e/S, votre serveur sera très rapidement paralysé.

   ---

   La seule fois que j'avais envisager d'utiliser *Sync méthodes dans un serveur d'application est une opération qui se passe une fois (et une seule fois), au démarrage. Par exemple, require utilise readFileSync pour le chargement des modules.

   Même alors, vous devez toujours être prudent, car beaucoup d'e/S synchrones peuvent être inutilement ralentir votre serveur de temps de démarrage.

   ---

   Au lieu de cela, vous devriez utiliser les e/S asynchrones méthodes.

Donc, si nous mettons ensemble de ces conseils, nous obtenons quelque chose comme ceci:

function ensureExists(path, mask, cb) {
    if (typeof mask == 'function') { //allow the `mask` parameter to be optional
        cb = mask;
        mask = 0777;
    }
    fs.mkdir(path, mask, function(err) {
        if (err) {
            if (err.code == 'EEXIST') cb(null); //ignore the error if the folder already exists
            else cb(err); //something else went wrong
        } else cb(null); //successfully created folder
    });
}

Et nous pouvons l'utiliser comme ceci:

ensureExists(__dirname + '/upload', 0744, function(err) {
    if (err) //handle folder creation error
    else //we're all good
});

---

Bien sûr, cela ne tient pas compte des cas limites comme

• Ce qui se passe si le dossier est supprimé alors que votre programme est en cours d'exécution? (en supposant que vous ne vérifiez qu'il n'existe qu'une fois pendant le démarrage)
• Ce qui se passe si le dossier existe déjà, mais avec la mauvaise autorisations?

Juste au cas où toute personne intéressée dans une version en ligne. 🙂

//or in typescript: import * as fs from 'fs';
const fs = require('fs');
!fs.existsSync(dir) && fs.mkdirSync(dir);

Vous pouvez simplement utiliser mkdir et de capture de l'erreur si le dossier existe.

C'est async (donc de meilleures pratiques) et coffre-fort.

fs.mkdir('/path', err => { 
    if (err && err.code != 'EEXIST') throw 'up'
    .. safely do your stuff here  
    })

(Éventuellement ajouter un deuxième argument à la mode.)

---

D'autres pensées:

1. Vous pourriez utiliser, puis sur ou à attendre en utilisant natif promisify.

   const util = require('util'), fs = require('fs');
   const mkdir = util.promisify(fs.mkdir);
   var myFunc = () => { ..do something.. } 
   
   mkdir('/path')
       .then(myFunc)
       .catch(err => { if (err.code != 'EEXIST') throw err; myFunc() })

2. Vous pouvez faire votre propre promesse méthode, quelque chose comme (non testé):

   let mkdirAsync = (path, mode) => new Promise(
      (resolve, reject) => mkdir (path, mode, 
         err => (err && err.code !== 'EEXIST') ? reject(err) : resolve()
         )
      )

3. Pour le vérifier, vous pouvez utiliser:

   fs.existsSync(path) || fs.mkdirSync(path)

4. Ou vous pouvez utiliser une bibliothèque, les deux plus populaires étant

   • mkdirp (juste ne dossiers)
   • fsextra (supersets fs, ajoute beaucoup de choses utiles)

Avec le fs-extra paquet, vous pouvez faire cela avec un one-liner:

const fs = require('fs-extra');

const dir = '/tmp/this/path/does/not/exist';
fs.ensureDirSync(dir);

    var filessystem = require('fs');
    var dir = './path/subpath/';

    if (!filessystem.existsSync(dir)){
        filessystem.mkdirSync(dir);
    }else
    {
        console.log("Directory already exist");
    }

Cela peut vous aider 🙂

Vous pouvez utiliser un nœud Système De Fichiers commande fs.stat pour vérifier si le répertoire existe et fs.mkdir pour créer un répertoire avec de rappel, ou fs.mkdirSync pour créer un répertoire sans rappel, comme dans cet exemple:

//first require fs
const fs = require('fs');

//Create directory if not exist (function)
const createDir = (path) => {
    //check if dir exist
    fs.stat(path, (err, stats) => {
        if (stats.isDirectory()) {
            //do nothing
        } else {
            //if the given path is not a directory, create a directory
            fs.mkdirSync(path);
        }
    });
};

ENOENT: aucun fichier ou répertoire de

Solution

const fs = require('fs')  //in javascript
import * as fs from "fs"  //in typescript
import fs from "fs"       //in typescript

!fs.existsSync(`./assets/`) && fs.mkdirSync(`./assets/`, { recursive: true })

À l'aide async /await:

const mkdirP = async (directory) => {
  try {
    return await fs.mkdirAsync(directory);
  } catch (error) {
    if (error.code != 'EEXIST') {
      throw e;
    }
  }
};

Vous aurez besoin de promisify fs:

import nodeFs from 'fs';
import bluebird from 'bluebird';

const fs = bluebird.promisifyAll(nodeFs);