Node.js kullanarak yoksa bir dizin nasıl oluşturulur?

Varsa, bir dizin oluşturmanın doğru yolu budur. Komut dosyası için tam izne sahip olmalı ve diğerleri tarafından okunabilir olmalıdır.

var dir = __dirname + '/upload';
if (!path.existsSync(dir)) {
    fs.mkdirSync(dir, 0744);
}

var fs = require('fs');
var dir = './tmp';

if (!fs.existsSync(dir)){
    fs.mkdirSync(dir);
}

Hayır, birçok nedenden dolayı.

1. pathModül, bulunmamaktadır exists/ existsSyncyöntem. Bu ise fsmodül. (Belki de sorunuzda bir yazım hatası yaptınız mı?)

2. Dokümanlar sizi kullanmanızı kesinlikle engelliyorexists .

   fs.exists()bir anakronizmdir ve sadece tarihsel nedenlerle var olur. Kendi kodunuzda kullanmak için neredeyse hiçbir zaman bir sebep olmamalıdır.

   Başka bir işlem için çağrılar arasında dosya kaldırabilir: Özellikle, bir dosya açmadan önce varsa o yapraklar o savunmasız yarış koşullarına bir anti-kalıptır kontrol fs.exists()ve fs.open(). Sadece dosyayı açın ve orada olmadığında hatayı halledin.

   Bir dosya yerine bir dizin hakkında konuştuğumuz için, bu öneri sadece koşulsuz olarak çağırmanız mkdirve görmezden gelmeniz gerektiği anlamına gelir EEXIST.

3. Genel olarak * Syncyöntemlerinden kaçınmalısınız . Engelliyorlar, yani diske giderken programınızda kesinlikle başka hiçbir şey olamaz. Bu çok pahalı bir işlemdir ve geçen süre, düğümün olay döngüsünün temel varsayımını kırar.

   * SyncYöntemleri genellikle tek amaçlı hızlı komut dosyalarında (bir şey yapan ve sonra çıkanlar) iyidir, ancak bir sunucu yazarken neredeyse hiç kullanılmamalıdır: sunucunuz tüm süre boyunca kimseye yanıt veremez G / Ç istekleri. Birden fazla istemci isteği G / Ç işlemleri gerektiriyorsa, sunucunuz çok hızlı bir şekilde durma noktasına gelecektir.

   ---

   SyncBir sunucu uygulamasında * yöntemlerini kullanmayı düşünebileceğim tek zaman başlangıçta bir kez (ve sadece bir kez) gerçekleşen bir işlemdir . Örneğin, require aslındareadFileSync modülleri yüklemek için kullanılır.

   O zaman bile, dikkatli olmalısınız çünkü birçok senkronize G / Ç sunucunuzun başlatma süresini gereksiz yere yavaşlatabilir.

   ---

   Bunun yerine, zaman uyumsuz G / Ç yöntemlerini kullanmalısınız.

Bu tavsiyeleri bir araya getirirsek, şöyle bir şey elde ederiz:

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

Ve bunu şu şekilde kullanabiliriz:

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

Tabii ki, bu gibi son durumları açıklamaz

• Programınız çalışırken klasör silinirse ne olur? (başlangıçta yalnızca bir kez bulunduğunu kontrol ettiğiniz varsayılarak)
• Klasör zaten mevcut ancak yanlış izinlere sahipse ne olur?

Buldum ve bunun için bir cazibe gibi çalışan npm modülü. Sadece bir "mkdir -p" gibi, gerektiğinde özyinelemeli bir mkdir yapmak.

https://www.npmjs.com/package/mkdirp

mkdirYöntem yeteneğine sahiptir yinelemeli oluşturmak bulunmayıp bir yolda bir dizin ve yapacak olanları görmezden.

Gönderen Düğüm v10 / 11 docs :

// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.
fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
    if (err) throw err;
});

NOT: Önce yerleşik fsmodülü içe aktarmanız gerekir .

Şimdi, yerel ES Modüllerinden (işaret etkin ve .mjs uzantısıyla) yararlanan, kök olmayan yolları işleyen ve tam yol adlarını açıklayan biraz daha sağlam bir örnek:

import fs from 'fs';
import path from 'path';

createDirectories(pathname) {
   const __dirname = path.resolve();
   pathname = pathname.replace(/^\.*\/|\/?[^\/]+\.[a-z]+|\/$/g, ''); // Remove leading directory markers, and remove ending /file-name.extension
   fs.mkdir(path.resolve(__dirname, pathname), { recursive: true }, e => {
       if (e) {
           console.error(e);
       } else {
           console.log('Success');
       }
    });
}

Gibi kullanabilirsiniz createDirectories('/components/widget/widget.js');.

Ve elbette, dizinler oluşturulduğunda dosya oluşturmayı daha okunabilir senkron görünümlü bir şekilde kullanmak için zaman uyumsuz / beklemede olan vaatleri kullanarak muhtemelen daha süslü olmak istersiniz; ancak bu, sorunun kapsamının dışındadır.

Bir satır sürümü ile ilgilenen herhangi bir durumda. :)

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

mkdirKlasör varsa hatayı kullanabilir ve yakalayabilirsiniz.
Bu zaman uyumsuz (en iyi uygulama) ve güvenlidir.

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

(İsteğe bağlı olarak modla ikinci bir bağımsız değişken ekleyin.)

Diğer düşünceler:

1. O zaman kullanabilirsiniz veya yerel promisify kullanarak bekleyebilirsiniz .

   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. Kendi vaat yönteminizi yapabilirsiniz (denenmemiş):

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

3. Senkronize kontrol için şunları kullanabilirsiniz:

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

4. Veya en popüler ikisi olan bir kütüphaneyi kullanabilirsiniz

   • mkdirp (sadece klasörler yapar)
   • fsextra ( supsets fs, çok sayıda faydalı öğe ekler)

İle fs-ekstra paketin size ile yapabilirsiniz tek astar :

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

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

En iyi çözüm node-fs-extra adlı npm modülünü kullanmak olacaktır . mkdirBahsettiğiniz dizini oluşturan denilen bir yöntemi vardır . Uzun bir dizin yolu verirseniz, üst klasörler otomatik olarak oluşturulur. Modül süper bir npm modülü kümesidir fs, bu nedenle fsbu modülü eklerseniz tüm işlevleri de kullanabilirsiniz .

var dir = 'path/to/dir';
try {
  fs.mkdirSync(dir);
} catch(e) {
  if (e.code != 'EEXIST') throw e;
}

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

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

Bu size yardımcı olabilir :)

ENOENT: böyle bir dosya veya dizin yok

Çözüm

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

// it will create the directory if it does not exist.
!fs.existsSync(`./assets/`) && fs.mkdirSync(`./assets/`, { recursive: true })

Josh3736'nın cevabına bir Typcript Promise refactoru eklemek istiyorum .

Aynı şeyi yapar ve aynı kenar durumlarda vardır, sadece Promises, daktilo tip tanımları kullanmak ve "katı kullanın" ile çalışır.

// https://en.wikipedia.org/wiki/File_system_permissions#Numeric_notation
const allRWEPermissions = parseInt("0777", 8);

function ensureFilePathExists(path: string, mask: number = allRWEPermissions): Promise<void> {
    return new Promise<void>(
        function(resolve: (value?: void | PromiseLike<void>) => void,
            reject: (reason?: any) => void): void{
            mkdir(path, mask, function(err: NodeJS.ErrnoException): void {
                if (err) {
                    if (err.code === "EEXIST") {
                        resolve(null); // ignore the error if the folder already exists
                    } else {
                        reject(err); // something else went wrong
                    }
                } else {
                    resolve(null); // successfully created folder
                }
            });
    });
}

Düğüm 10 + ES6 ile:

import path from 'path';
import fs from 'fs';

(async () => {
  const dir = path.join(__dirname, 'upload');

  try {
    await fs.promises.mkdir(dir);
  } catch (error) {
    if (error.code === 'EEXIST') {
      // Something already exists, but is it a file or directory?
      const lstat = await fs.promises.lstat(dir);

      if (!lstat.isDirectory()) {
        throw error;
      }
    } else {
      throw error;
    }
  }
})();

Sen düğüm kullanabilirsiniz Dosya Sistemi komut fs.stat dir varsa ve kontrol etmek fs.mkdir geri arama ile bir dizin oluşturmak için, ya fs.mkdirSync bu örnekte olduğu gibi, geri arama olmadan bir dizin oluşturmak için:

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

İşte dizinleri özyinelemeli olarak oluşturmak için küçük bir işlev:

const createDir = (dir) => {
  // This will create a dir given a path such as './folder/subfolder' 
  const splitPath = dir.split('/');
  splitPath.reduce((path, subPath) => {
    let currentPath;
    if(subPath != '.'){
      currentPath = path + '/' + subPath;
      if (!fs.existsSync(currentPath)){
        fs.mkdirSync(currentPath);
      }
    }
    else{
      currentPath = subPath;
    }
    return currentPath
  }, '')
}

Async / await kullanma:

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

Söz vermeniz gerekecek fs:

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

const fs = bluebird.promisifyAll(nodeFs);