Node.js klasör oluştur veya mevcut olanı kullan

Zaten Node.js belgelerini okudum ve bir şey kaçırmazsam, özellikle belirli işlemlerde parametrelerin ne içerdiğini söylemez fs.mkdir(). Belgelerde gördüğünüz gibi, çok fazla değil.

Şu anda, bir klasör oluşturmaya veya bunun yerine varolan bir klasörü kullanmaya çalışan bu kodu var:

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

Ama merak ediyorum bunu yapmanın doğru yolu bu mu? Kodun kontrol EEXISTedilmesi, klasörün zaten var olduğunu bilmenin doğru yolu mu? Ben fs.stat()dizin yapmadan önce yapabileceğimi biliyorum , ama bu zaten dosya sistemine iki hit olurdu.

İkinci olarak, Node.js'nin hangi hata nesnelerinin içerdiği, hangi parametrelerin ne anlama geldiği vb.

Bunu yapmanın iyi bir yolu mkdirp modülünü kullanmaktır .

$ npm install mkdirp

Dizini gerektiren işlevi çalıştırmak için kullanın. Yol oluşturulduktan sonra veya yol zaten mevcutsa geri arama çağrılır. errMkdirp dizin yolu oluşturamazsa hata ayarlanır.

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

    // path exists unless there was an error

});

Edit: Bu cevap çok popüler olduğu için, güncel uygulamaları yansıtacak şekilde güncelledim.

Düğüm> = 10

{ recursive: true }Düğümlerin yeni seçeneği fsartık buna doğal olarak izin veriyor. Bu seçenek UNIX'lerin davranışlarını taklit eder mkdir -p. Yolun her bölümünün yinelemeli olarak olmasını sağlar ve bunlardan herhangi biri varsa hata atmaz.

(Not: yine de EPERMveya gibi hatalar atabilir EACCESS, bu yüzden try {} catch (e) {}uygulamanız buna duyarlıysa daha iyi sarın .)

Senkron versiyon.

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

Zaman uyumsuz sürüm

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

Eski Düğüm sürümleri

A kullanarak try {} catch (err) {}, bunu bir yarış durumu ile karşılaşmadan çok zarif bir şekilde başarabilirsiniz.

Varlığı denetleme ve dizini oluşturma arasındaki ölü zamanı önlemek için, dizini doğrudan oluşturmaya çalışırız ve varsa hatayı göz ardı ederiz EEXIST(dizin zaten var).

EEXISTAncak hata değilse , bir hata atmalıyız, çünkü bir EPERMveyaEACCES

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

İçin mkdir -p-like özyinelemeli davranış, örneğin ./a/b/c, sen dirpath her bölümünde üzerinde demelisiniz, örneğin ./a, ./a/b,.a/b/c

Hızlı ve kirli bir astar istiyorsanız, bunu kullanın:

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

Node.js, fs.mkdirtemelde Linux kılavuz sayfasına ertelendi mkdir(2). Bu EEXIST, yolun mevcut olması durumunda da belirtileceğini, ancak bu rotaya giderseniz garip bir köşe durumu oluşturan bir dizin olmadığını gösterir.

fs.statAramanın daha iyi bir yolu olabilir, bu da yolun mevcut olup olmadığını ve tek bir çağrıda bir dizin olup olmadığını söyler. Dizin zaten var olduğu normal durumda (varsayalım), sadece tek bir dosya sistemi isabet.

Bu fsmodül yöntemleri, yerel C API'lerinin etrafındaki ince sarmalayıcılardır, bu nedenle ayrıntılar için node.js belgelerinde başvurulan man sayfalarını kontrol etmeniz gerekir.

Bunu kullanabilirsiniz:

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

Modülsüz bir çözüm öneriyorum (modülleri biriktirmek, özellikle birkaç satırda yazılabilen küçük işlevler için sürdürülebilirlik için asla tavsiye edilmez ...):

SON GÜNCELLEME :

V10.12.0'da, NodeJS uygulaması özyinelemeli seçenekler:

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

GÜNCELLEME :

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

Ayrıca fs-extra kullanabilirsinizSık kullanılan dosya işlemlerinin çoğunu sağlayan .

Basit kod:

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

burada dokümanlar: https://github.com/jprichardson/node-fs-extra#mkdirsdir-callback

İşte bir dizin oluşturmak için kullandığım ES6 kodu (yok olduğunda):

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

Not:

• Başında createDirectoryfonksiyonu, ben (örneğin, bu dönecek işletim sisteminin yol ayırıcı tipi sürekli kullanılacağını garanti yolunu normalleştirmek C:\directory/testiçine C:\directory\test(Windows üzerinde olmaları durumunda)
• fs.existskullanımdan kaldırıldı , bu yüzden kullanıyorumfs.stat dizinin zaten var olup olmadığını kontrol etmek için
• Bir dizin yoksa, hata kodu ENOENT( E rror NO ENT) ry) olacaktır.
• Dizinin kendisi kullanılarak oluşturulacaktır fs.mkdir
• Eşzamanlı fs.mkdirengelleme karşı zaman uyumsuz işlevi tercih ve fs.mkdirSyncsarma nedeniyle Promisedizinin yolunun yalnızca dizin başarıyla oluşturulduktan sonra döndürüleceği garanti edilecektir

Bence Javascript'te kod yazarken dosya sistemi isabetlerini saymamak daha iyi olur. Ancak, (1) stat& mkdirve (2) mkdirve hata kodunu kontrol edin (veya atın), her iki yol da istediğinizi yapmak için doğru yoldur.

her kullanıcı için dinamik ad dizini oluştur ... bu kodu kullan

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

Tüm bunları Dosya Sistemi modülüyle yapabilirsiniz.

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

Dizinin var olup olmadığını gerçekten kontrol etmeniz bile gerekmez. Aşağıdaki kod, dizinin zaten var olduğunu veya oluşturulduğunu da garanti eder.

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

Raugaral'ın yanıtı -p işlevselliği ile. Çirkin, ama işe yarıyor:

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

Tıpkı Teemu Ikonen'in cevabına çok basit ve kolayca okunabilen daha yeni bir alternatif olarak paketin ensureDiryöntemini kullanmaktır fs-extra.

Sadece dahili fsmodül için açık bir yedek olarak değil , aynı zamanda fspaketin işlevlerine ek olarak birçok başka işleve de sahiptir .

ensureDirAdından da anlaşılacağı gibi yöntem, dizinin mevcut olmasını sağlar. Dizin yapısı yoksa oluşturulur. Sevmekmkdir -p . Yalnızca bitiş klasörü değil, zaten yoksa tüm yol oluşturulur.

yukarıda verilen asyncsürümdür. Ayrıca bunu yöntem şeklinde gerçekleştirmek için eşzamanlı bir yöntemi vardır ensureDirSync.

@ Liberateur'un yukarıdaki cevabı benim için işe yaramadı (Düğüm v8.10.0). Küçük bir değişiklik hile yaptı ama bunun doğru bir yol olup olmadığından emin değilim. Lütfen önerin.

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