Node.js फ़ोल्डर बनाते हैं या मौजूदा का उपयोग करते हैं

Question

मैंने पहले से ही Node.js के दस्तावेज़ीकरण को पढ़ा है और, जब तक कि अगर मैं कुछ याद नहीं करता, तो यह नहीं बताता कि कुछ विशेष कार्यों में पैरामीटर क्या हैं fs.mkdir()। जैसा कि आप प्रलेखन में देख सकते हैं, यह बहुत ज्यादा नहीं है।

वर्तमान में, मेरे पास यह कोड है, जो एक फ़ोल्डर बनाने या इसके बजाय किसी मौजूदा का उपयोग करने की कोशिश करता है:

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

लेकिन मुझे आश्चर्य है कि क्या यह ऐसा करने का सही तरीका है? क्या EEXISTयह जानने के लिए कि फ़ोल्डर पहले से मौजूद है , कोड की सही तरीके से जाँच कर रहा है? मुझे पता है कि मैं fs.stat()डायरेक्टरी बनाने से पहले कर सकता हूं , लेकिन वह पहले से ही फाइलसिस्टम के लिए दो हिट होगी।

दूसरे, क्या Node.js का एक पूर्ण या कम से कम अधिक विस्तृत प्रलेखन है जिसमें यह विवरण है कि त्रुटि वाले ऑब्जेक्ट में क्या पैरामीटर हैं, कौन से पैरामीटर इंगित करते हैं आदि।

Comments

छोटे निपिक, लेकिन छुटकारा e &&। अगर !eअसफल होता है, तो आप जानते हैं eकि सच्चाई है।

— हेट लज़ीज़

Answer 1

ऐसा करने का अच्छा तरीका mkdirp मॉड्यूल का उपयोग करना है।

$ npm install mkdirp

फ़ंक्शन का उपयोग करने के लिए इसका उपयोग निर्देशिका की आवश्यकता होती है। पथ बनाने के बाद या यदि पथ पहले से मौजूद था, तो कॉलबैक कहा जाता है। errयदि निर्देशिका पथ बनाने में विफल हुआ तो त्रुटि सेट की गई है।

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

    // path exists unless there was an error

});

Comments

यह मुझे सही लगता है (पढ़ें-नो-डिपेंडेंसी-एडेड ’) जवाब @Raugaral, का उपयोग करके, नीचे एक कम होगा fs.exists(Sync)।

— रिकार्डो पेड्रोनी

@meawoppl, यह 'makedirectory'p' है। 'P' अज्ञात है।

— andrew

@RicardoPedroni मॉड्यूल का उपयोग करने का सही तरीका है। मॉड्यूल आमतौर पर पूरे दिल से एक समस्या को हल करने की कोशिश कर रहे हैं, और अक्सर बनाए रखा जाता है। आप उन्हें आसानी से npm से अपडेट कर सकते हैं। इसके अलावा, आपको विशेष रूप से fs.exists [सिंक] का उपयोग करने से बचना चाहिए क्योंकि इसका उपयोग दौड़ की स्थिति को दर्शाता है।

— 1j01

@ 1j01 मुझे विश्वास नहीं है कि एक मॉड्यूल का उपयोग करने का सही तरीका है यदि प्लेटफॉर्म मूल रूप से ऑपरेशन का समर्थन करता है। वह अराजकता का रास्ता है। मुझे इस बात से सहमत होना होगा कि तकनीकी दृष्टिकोण से बेहतर उत्तर हैं।

— c ..

@ 1j01 इसके अलावा, सिंक ऑपरेशन का उपयोग करते हुए दौड़ की स्थिति का पता लगाते हैं क्योंकि उनका उपयोग उनके लिए एक संकल्प है।

— c ..

Answer 2

संपादित करें: क्योंकि यह उत्तर बहुत लोकप्रिय है, मैंने इसे अद्यतित प्रथाओं को प्रतिबिंबित करने के लिए अद्यतन किया है।

नोड> = 10

{ recursive: true }नोड का नया विकल्प fsअब इसे मूल रूप से अनुमति देता है। यह विकल्प UNIX के व्यवहार की नकल करता है mkdir -p। यह निश्चित रूप से यह सुनिश्चित करेगा कि रास्ते का हर हिस्सा मौजूद है, और उनमें से कोई भी एक त्रुटि नहीं करेगा।

(ध्यान दें: यह अभी भी त्रुटियों को फेंक सकता है जैसे कि , EPERMया EACCESSतो बेहतर अभी भी इसे लपेटें try {} catch (e) {}यदि आपका कार्यान्वयन इसके लिए अतिसंवेदनशील है।)

तुल्यकालिक संस्करण।

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

Async संस्करण

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

पुराने नोड संस्करण

एक का उपयोग कर try {} catch (err) {}, आप एक दौड़ हालत का सामना किए बिना यह बहुत ही शानदार ढंग से प्राप्त कर सकते हैं।

अस्तित्व की जाँच करने और निर्देशिका बनाने के बीच मृत समय को रोकने के लिए, हम बस इसे सीधे बनाने की कोशिश करते हैं, और यदि है तो त्रुटि की अवहेलना करते हैं EEXIST (निर्देशिका पहले से मौजूद है) ।

यदि त्रुटि नहीं है EEXIST, हालांकि, हमें एक त्रुटि फेंकना चाहिए, क्योंकि हम किसी चीज़ से निपट सकते हैं EPERMया जैसेEACCES

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

के लिए mkdir -pकी तरह पुनरावर्ती व्यवहार, जैसे ./a/b/c, आप dirpath के हर हिस्से पर इसे कहते करना होगा, जैसे ./a, ./a/b,.a/b/c

Comments

var fs = Npm.require ('fs'); var dir = process.env.PWD + '/ files / users /' + this.userId + '/'; {fs.mkdirSync (dir) आज़माएँ; } catch (e) {if (e.code! '' EEXIST ') फेंकना e; }

— हारून

मैंने आपका कोड आज़माया, एक js-script बनाई, जो कैटलॉग क्रिएशन का उपयोग करती है: mkdirpSync (path.join (__ dirname, 'first', 'second', 'third', 'ololol', 'works')); लेकिन यह त्रुटि मिली: $ नोड 1.js fs.js: 747 रिटर्न बाइंडिंग.mddir (pathModule._makeLong (पथ), ^ त्रुटि: EPERM, ऑपरेशन की अनुमति नहीं 'C: \' पर त्रुटि (मूल) Object.fs पर। mkdirSync (fs.js: 747: 18) पर mkdirpSync (C: \ Users \ MAXIM \ Desktop \ test \ 1.js: 15: 8) ऑब्जेक्ट पर। <अनाम> (C: अन्य उपयोगकर्ता \ MAXIM \ Desktop \ test \ test)। 1.js: 19: 1) ... क्या आप सुझाव दे सकते हैं कि क्या गलत हो सकता है? जाहिर तौर पर खिड़कियों पर प्रयोग किया जाता है :)

— Alendorff

EPERM एक अनुमति मुद्दे की तरह लगता है, इसलिए पटकथा टूटी हुई निष्पादन को वैसे भी समाप्त कर देगी

— क्रिस्टोफ मैरिस

मुझे लगता है कि यह बेहतर होगा: var mkdirpSync = function (dirpath) {var parts = dirpath.split (path.sep); for (var i = 1; i <= parts.length; i ++) {try {fs.mkdirSync (path.join.apply (null, parts.slice (0, i))); } catch (एरर) {if (error.code! = 'EEXIST') {थ्रो एरर; }}}}

— मनीष

चेतावनी: यह काम नहीं करता है यदि आपका मार्ग

— acemtp

Answer 3

यदि आप एक त्वरित और गंदा लाइनर चाहते हैं, तो इसका उपयोग करें:

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

Comments

fs.existsपदावनत किया गया है: nodejs.org/api/fs.html#fs_fs_exists_path_callback

— adius

fs.existsSync (...) को पदावनत नहीं किया जाता है, हालांकि, यह उत्तर ठीक लगता है।

— डैन हयावुड

सचेत! "दिर / फू / बार" के लिए काम नहीं करेंगे, अर्थात एमकेडीआईआर-पी ध्वज सुविधा का अभाव है

— कार्ल पोकस

इसकी एक दौड़ की स्थिति भी है

— Evert

Answer 4

के लिए fs.mkdirमूल रूप से लिनक्स मैन पेज के लिए नोड.जेएस डॉक्स सुरक्षित हैं mkdir(2)। यह इंगित करता है कि EEXISTयदि मार्ग मौजूद है, तो भी संकेत दिया जाएगा, लेकिन यदि आप इस मार्ग पर जाते हैं तो एक अजीब कोने वाला मामला नहीं बनता है।

आप कॉलिंग से बेहतर हो सकते हैं fs.statजो आपको बताएगा कि क्या पथ मौजूद है और यदि यह एक कॉल में एक निर्देशिका है। के लिए (मैं जो मान रहा हूं) सामान्य मामला है जहां निर्देशिका पहले से मौजूद है, यह केवल एक ही फाइल सिस्टम हिट है।

ये fsमॉड्यूल विधियाँ मूल C API के आस-पास पतली आवरण हैं ताकि आपको विवरण के लिए नोड.जेएस डॉक्स में संदर्भित मैन पेजों की जाँच करने में मदद मिले।

Comments

कॉल करने statसे पहले mkdirएक दौड़ की स्थिति की संभावना है - इसे ध्यान में रखें।

— रोजर लिप्सकॉम्ब

Answer 5

आप इसका उपयोग कर सकते हैं:

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

Comments

-1। मुझे विश्वास नहीं है कि यह काम करता है, statSyncएक त्रुटि को फेंक देगा यदि इकाई बिल्कुल भी मौजूद नहीं है, कोड को दुर्घटनाग्रस्त कर देगा। आपको इसे एक try/catchब्लॉक में लपेटने की आवश्यकता है ।

— क्रिस फोस्टर

खेद है कि मैं गलत कर रहा हूँ। "StatSync" के लिए "अस्तित्वसंचालक"

— बदलें

Ndjs.org/api/fs.html#fs_fs_mkdirsync_path_mode के अनुसार mkdir का सिंक वैरिएंट कॉलबैक स्वीकार नहीं करता है

— danwellman

Nodejs.org/api/fs.html#fs_fs_existssync_path के अनुसार , fs.existsSync()और fs.exists()उसे हटा दिया जाएगा।

— पौनोरेनो

Answer 6

मैं मॉड्यूल के बिना एक समाधान का प्रस्ताव करता हूं (संचित मॉड्यूल को विशेष रूप से छोटे कार्यों के लिए स्थिरता के लिए अनुशंसित नहीं किया जाता है जिन्हें कुछ पंक्तियों में लिखा जा सकता है ...):

आखिरी अपडेट :

V10.12.0 में, NodeJS की पुनरावृत्ति पुनरावर्ती विकल्प:

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

अपडेट करें :

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

Comments

fs.exists()नोड v9 में पदावनत है। fs.access()इसके बजाय का उपयोग करें । ( undefinedयदि फ़ाइल मौजूद है, तो वापस आ जाता है; अन्यथा एक त्रुटि फेंकता है ENOENT)

— chharvey

बिना किसी npm पैकेज के, यह काम कर रहा है। यह एक मूल्यवान कोड है। धन्यवाद

— कार्तिक श्रीधरन

मौजूदा लंबे रास्ते के तहत एक फ़ोल्डर बनाने के लिए यह काफी बेहतर है; धन्यवाद, आदमी।

— त्सुंग गोह

किस बारे में fs.mkdirSync('my/new/folder/create', {recursive: true})?

— saitho

धन्यवाद ! मैं दूसरों की मदद करने के लिए अपनी पोस्ट अपडेट करता हूं। नोड 10.12.0 बहुत हाल ही में था।

— लिबरेटर

Answer 7

आप एफएस-अतिरिक्त का भी उपयोग कर सकते हैं , जो बहुत बार उपयोग किए जाने वाले फ़ाइल संचालन प्रदान करते हैं।

नमूना कोड:

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

डॉक्स यहां: https://github.com/jprichardson/node-fs-extra#mkdirsdir-cbback

Answer 8

यहां ES6 कोड है जिसका उपयोग मैं एक निर्देशिका बनाने के लिए करता हूं (जब यह मौजूद नहीं है):

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

ध्यान दें:

• की शुरुआत में createDirectoryसमारोह, मैं (जैसे यह हो जाएगा गारंटी नहीं है कि ऑपरेटिंग सिस्टम के मार्ग विभाजक प्रकार लगातार उपयोग किया जाएगा करने के लिए पथ को सामान्य C:\directory/testमें C:\directory\test(जब विंडोज पर किया जा रहा है)
• fs.existsहै पदावनत , यही कारण है कि मैं का उपयोग करें fs.statयदि निर्देशिका पहले से मौजूद जाँच करने के लिए
• यदि कोई निर्देशिका मौजूद नहीं है, तो त्रुटि कोड होगा ENOENT( E rror NO ENT ry)
• निर्देशिका का उपयोग कर बनाया जाएगा fs.mkdir
• मैं प्रतिसंतुलित फ़ंक्शन fs.mkdirपर अतुल्यकालिक फ़ंक्शन को पसंद करता हूं fs.mkdirSyncऔर रैपिंग के कारण Promiseयह गारंटी दी जाएगी कि निर्देशिका का पथ केवल निर्देशिका सफलतापूर्वक बनाए जाने के बाद वापस कर दिया जाएगा

Comments

एक साफ समाधान के लिए धन्यवाद जिसमें अनावश्यक मॉड्यूल शामिल नहीं हैं। इसने मेरे लिए पूरी तरह से काम किया। काश इस तरह के और भी उत्तर होते!

— केन लियोन

Answer 9

जब आप जावास्क्रिप्ट को कोड करते हैं, तो मेरी राय में आप फाइलसिस्टम हिट की गिनती बेहतर नहीं करेंगे। हालांकि, (1) statऔर mkdir(2) mkdirऔर चेक (या छोड़ें) त्रुटि कोड, दोनों तरीकों से सही तरीके तुम क्या चाहते करने के लिए कर रहे हैं।

Comments

-1, मैं यह नहीं देखता कि या तो जाँचना या छोड़ना दोनों ही इसे करने के सही तरीके हो सकते हैं। यह बहुत गैर जवाब है।

— मैट बॉल

यह निर्देशिका को mkdir करने या मौजूदा का उपयोग करने का एक अच्छा तरीका है। मैं नहीं देखता कि तुम क्यों नहीं देखते। त्रुटि कोड की जाँच करना एक अच्छा है, जबकि त्रुटि कोड को छोड़ना सिर्फ एक अच्छा है। क्या आप सहमत नहीं हैं?

— चुल-वोओंग यांग

हो सकता है कि यह एक भाषा बाधा समस्या है, लेकिन मैंने इसे ओपी पूछ रहा है कि सवाल का जवाब नहीं देने के रूप में पढ़ा।

— मैट बॉल

मैं देख रहा हूं कि आपकी बात क्या है हालांकि, मेरा मानना ​​है कि चीजों को सही तरीके से करने के कई तरीके हैं। धन्यवाद।

— चुल-वूंग यांग

Answer 10

प्रत्येक उपयोगकर्ता के लिए डायनामिक नाम निर्देशिका बनाएं ... इस कोड का उपयोग करें

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

Answer 11

आप फ़ाइल सिस्टम मॉड्यूल के साथ यह सब कर सकते हैं।

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

यदि निर्देशिका मौजूद है तो आपको वास्तव में जांचने की आवश्यकता नहीं है। निम्न कोड यह भी गारंटी देता है कि निर्देशिका या तो पहले से मौजूद है या बनाई गई है।

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

Answer 12

राउगरल का जवाब लेकिन -p कार्यक्षमता के साथ। बदसूरत, लेकिन यह काम करता है:

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

Answer 13

टीमू आइकोनन के जवाब के नए विकल्प के रूप में , जो बहुत ही सरल और आसानी से पठनीय है, पैकेज की ensureDirविधि का उपयोग करना है fs-extra।

इसका उपयोग न केवल fsमॉड्यूल में निर्मित के लिए एक स्पष्ट प्रतिस्थापन के रूप में किया जा सकता है , बल्कि fsपैकेज की कार्यात्मकताओं के अलावा कई अन्य प्रकार की कार्यक्षमता भी है ।

ensureDirविधि, के रूप में नाम का सुझाव सुनिश्चित करता है कि निर्देशिका मौजूद है। यदि निर्देशिका संरचना मौजूद नहीं है, तो इसे बनाया जाता है। की तरह mkdir -p। केवल अंतिम फ़ोल्डर ही नहीं, बल्कि पहले से मौजूद नहीं होने पर संपूर्ण पथ बनाया जाता है।

जो ऊपर दिया गया है, वह इसका asyncसंस्करण है। यह विधि के रूप में इसे करने के लिए एक तुल्यकालिक विधि भी है ensureDirSync।

Answer 14

@ ऊपर लिबरेटर का जवाब मेरे लिए काम नहीं किया (नोड v8.10.0)। थोड़ा संशोधन ने चाल चली लेकिन मुझे यकीन नहीं है कि यह एक सही तरीका है। कृपया सुझाव दे।

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