नोड के fs.mkdirSync के साथ पूर्ण पथ कैसे बनाएं?


159

मैं एक पूर्ण पथ बनाने की कोशिश कर रहा हूँ अगर यह मौजूद नहीं है।

कोड इस तरह दिखता है:

var fs = require('fs');
if (!fs.existsSync(newDest)) fs.mkdirSync(newDest); 

यह कोड तब तक बढ़िया काम करता है जब तक कि केवल एक उपनिर्देशिका ('dir1' जैसा एक नयाडेस्ट) हो, लेकिन जब कोई निर्देशिका पथ होता है, जैसे ('dir1 / dir2') यह त्रुटि के साथ विफल होता है : ENOENT, ऐसी कोई फ़ाइल या निर्देशिका नहीं

मैं कोड की कुछ पंक्तियों के साथ आवश्यक रूप से पूर्ण पथ बनाने में सक्षम होना चाहता हूं।

मैंने पढ़ा कि एफएस पर एक पुनरावर्ती विकल्प है और इसे इस तरह आज़माया

var fs = require('fs');
if (!fs.existsSync(newDest)) fs.mkdirSync(newDest,'0777', true);

मुझे ऐसा लगता है कि ऐसा होना चाहिए जो किसी निर्देशिका को पुन: बनाने के लिए सरल हो जो मौजूद नहीं है। क्या मुझे कुछ याद आ रहा है या क्या मुझे पथ को पार्स करने और प्रत्येक निर्देशिका की जांच करने और इसे बनाने की आवश्यकता है यदि यह पहले से मौजूद नहीं है?

मैं Node के लिए बहुत नया हूँ। शायद मैं FS के पुराने संस्करण का उपयोग कर रहा हूं?


1
github.com/substack/node-mkdirp और इस Google खोज पर अन्य सभी प्रकार के समाधान ।
5

4
@AndyRay यह स्टैकऑवरफ्लो प्रश्न अब इस प्रश्न के लिए Google में शीर्ष परिणाम है, जो कि हास्यास्पद है क्योंकि इसका मतलब है कि यह पुनरावृत्ति है ....
मैट पार्किंस

1
यह नोड के पुराने संस्करणों पर एक समस्या थी, नोड 12 को अपडेट करना + समस्या हल करता है
MrJomp

जवाबों:


48

एक विकल्प शेलज मॉड्यूल का उपयोग करना है

npm स्थापित शैलज

var shell = require('shelljs');
shell.mkdir('-p', fullPath);

उस पेज से:

उपलब्ध विकल्प:

पी: पूर्ण पथ (यदि आवश्यक हो तो मध्यवर्ती डायर बनाएगा)

जैसा कि अन्य ने उल्लेख किया है, अन्य अधिक केंद्रित मॉड्यूल हैं। लेकिन, mkdirp के बाहर, इसमें अन्य उपयोगी शेल ऑपरेशन (जैसे, grep आदि ...) के टन हैं और यह विंडोज़ और * निक्स पर काम करता है।


2
धन्यवाद! मैंने निष्पादन का उपयोग करना समाप्त कर दिया (मैं पहले से ही इसका उपयोग कर रहा था) और यह एक आकर्षण की तरह काम करता था। var exec = आवश्यकता ('child_process')। exec; var कमांड = "mkdir -p '" + newDest + "'"; var विकल्प = {}; var के बाद = function (error, stdout, stderr) {कंसोल.लॉग ('एरर', एरर); कंसोल.लॉग ('स्टडआउट', स्टडआउट); कंसोल.लॉग ('stderr', stderr); } निष्पादित (कमांड, विकल्प, के बाद);
डेविड सिल्वा स्मिथ

24
यह विकल्प नोड.जेएस प्लेटफॉर्म पर टूट सकता है जिसमें कमांड लाइन mkdir उदाहरण नहीं है (यानी, गैर-लिनक्स-वाई होस्ट) इसलिए यह पोर्टेबल नहीं है, अगर यह मायने रखता है।
cshotton

1
@cshotton - क्या आप टिप्पणी या जवाब का जिक्र कर रहे हैं? गोले खिड़कियों पर भी काम करते हैं। निष्पादित mkdir -p (टिप्पणी) बिल्कुल नहीं करता है।
ब्रायनमैक

आप इस शांत फ़ंक्शन का उपयोग अपनी पसंद के वादे या कॉलबैक के साथ कर सकते हैं ।
19

1
यह समाधान नहीं है, यह समाधान का एक विकल्प है। संदर्भ: pics.onsizzle.com/…
Nika Kasradze

412

संपादित करें

NodeJS संस्करण 10.12.0ने दोनों के लिए एक देशी समर्थन जोड़ा है mkdirऔर निम्नलिखित के रूप में विकल्प के mkdirSyncसाथ एक निर्देशिका बनाने के लिए recursive: true:

fs.mkdirSync(targetDir, { recursive: true });

और यदि आप चाहें fs Promises API, तो आप लिख सकते हैं

fs.promises.mkdir(targetDir, { recursive: true });

मूल उत्तर

यदि वे मौजूद नहीं हैं, तो पुनरावर्ती निर्देशिका बनाएँ! ( शून्य निर्भरता )

const fs = require('fs');
const path = require('path');

function mkDirByPathSync(targetDir, { isRelativeToScript = false } = {}) {
  const sep = path.sep;
  const initDir = path.isAbsolute(targetDir) ? sep : '';
  const baseDir = isRelativeToScript ? __dirname : '.';

  return targetDir.split(sep).reduce((parentDir, childDir) => {
    const curDir = path.resolve(baseDir, parentDir, childDir);
    try {
      fs.mkdirSync(curDir);
    } catch (err) {
      if (err.code === 'EEXIST') { // curDir already exists!
        return curDir;
      }

      // To avoid `EISDIR` error on Mac and `EACCES`-->`ENOENT` and `EPERM` on Windows.
      if (err.code === 'ENOENT') { // Throw the original parentDir error on curDir `ENOENT` failure.
        throw new Error(`EACCES: permission denied, mkdir '${parentDir}'`);
      }

      const caughtErr = ['EACCES', 'EPERM', 'EISDIR'].indexOf(err.code) > -1;
      if (!caughtErr || caughtErr && curDir === path.resolve(targetDir)) {
        throw err; // Throw if it's just the last created dir.
      }
    }

    return curDir;
  }, initDir);
}

प्रयोग

// Default, make directories relative to current working directory.
mkDirByPathSync('path/to/dir');

// Make directories relative to the current script.
mkDirByPathSync('path/to/dir', {isRelativeToScript: true});

// Make directories with an absolute path.
mkDirByPathSync('/path/to/dir');

डेमो

कोशिश करो!

स्पष्टीकरण

  • [अद्यतन] की तरह यह समाधान हैंडल मंच-विशिष्ट त्रुटियाँ EISDIRमैक और के लिए EPERMऔर EACCESWindows के लिए। @PediT।, @JohnQ, @ deed02392, @robyoder और @Almenon द्वारा सभी रिपोर्टिंग टिप्पणियों के लिए धन्यवाद।
  • यह समाधान सापेक्ष और निरपेक्ष दोनों रास्तों को संभालता है। @John टिप्पणी के लिए धन्यवाद।
  • रिश्तेदार रास्तों के मामले में, वर्तमान कार्यशील निर्देशिका में लक्ष्य निर्देशिकाएं (हल) बनाई जाएंगी। वर्तमान स्क्रिप्ट के सापेक्ष उन्हें हल करने के लिए, पास करें {isRelativeToScript: true}
  • क्रॉस-प्लेटफ़ॉर्म मुद्दों से बचने के लिए , का उपयोग करना path.sepऔर path.resolve(), न केवल /संघटन।
  • दौड़ की स्थितियों को संभालने के लिए फेंकने के fs.mkdirSyncसाथ त्रुटि का उपयोग करना और संभालना try/catch: एक अन्य प्रक्रिया कॉल के बीच फ़ाइल को जोड़ सकती है fs.existsSync()और fs.mkdirSync()अपवाद का कारण बन सकती है।
    • इसे प्राप्त करने का दूसरा तरीका यह हो सकता है कि यदि कोई फ़ाइल मौजूद है, तो उसे बनाकर, यानी if (!fs.existsSync(curDir) fs.mkdirSync(curDir);। लेकिन यह एक विरोधी पैटर्न है जो कोड को दौड़ की स्थिति के लिए असुरक्षित बनाता है। निर्देशिका अस्तित्व जाँच के बारे में @GershomMaes टिप्पणी के लिए धन्यवाद।
  • विनाशकारी का समर्थन करने के लिए नोड v6 और नए की आवश्यकता है । (यदि आपको पुराने नोड संस्करणों के साथ इस समाधान को लागू करने में समस्या है, तो बस मुझे एक टिप्पणी छोड़ दें)

7
एक अतिरिक्त पुस्तकालय या दृष्टिकोण की आवश्यकता नहीं है, आसान, पुनरावर्ती प्रतिक्रिया के लिए अपवोट करें!
मिकिंग द वाइकिंग 10

1
गुम बयानों की आवश्यकता होती है: const fs = आवश्यकता ('fs'); const path = आवश्यकता ('path');
क्रिस्टोफर बुल

1
@ChristopherBull, जानबूझकर केवल तर्क पर ध्यान केंद्रित करने के लिए नहीं जोड़ा गया, लेकिन वैसे भी, मैंने उन्हें जोड़ा। धन्यवाद;)
Mouneer

1
ठोस कोड की 12 लाइनें, शून्य निर्भरता, मैं इसे हर बार ले जाऊंगा।
मूडबूम

1
मैक ओएस एक्स 10.12.6 पर @Mouneer, एक पूर्ण पथ में गुजरने के बाद "/" बनाने की कोशिश करते समय त्रुटि "EISDIR" है (त्रुटि: EISDIR: एक निर्देशिका पर अवैध संचालन, mkdir '' ')। मुझे लगता है कि शायद dir अस्तित्व की जाँच करना अभी भी सबसे अच्छा क्रॉस-प्लेटफ़ॉर्म का रास्ता है (यह स्वीकार करना धीमा होगा)।
जॉन क्यू

78

एक और अधिक मजबूत जवाब है mkdirp का उपयोग करना

var mkdirp = require('mkdirp');

mkdirp('/path/to/dir', function (err) {
    if (err) console.error(err)
    else console.log('dir created')
});

फिर फ़ाइल को पूर्ण पथ में लिखने के लिए आगे बढ़ें:

fs.writeFile ('/path/to/dir/file.dat'....

इस उत्तर को प्राथमिकता दें क्योंकि आप केवल वही चीज आयात कर रहे हैं जो आपको चाहिए, पूरी लाइब्रेरी नहीं
जुआन मेंडेस

1
पॉपुलिस्ट बिल्ला पर बधाई ;-)
जूनोस

1
धन्यवाद। यह सबसे अच्छी विधि है।
स्टीफन राफेल


48

fs-extra फ़ाइल सिस्टम विधियों को जोड़ता है जो देशी fs मॉड्यूल में शामिल नहीं हैं। यह एफएस के प्रतिस्थापन में एक गिरावट है।

इंस्टॉल fs-extra

$ npm install --save fs-extra

const fs = require("fs-extra");
// Make sure the output directory is there.
fs.ensureDirSync(newDest);

वहाँ सिंक और async विकल्प हैं।

https://github.com/jprichardson/node-fs-extra/blob/master/docs/ensureDir.md


5
यह सबसे अच्छा जवाब है! हम में से ज्यादातर पहले से ही एप्लिकेशन में एफएस-अतिरिक्त है।
पेजप

यह बहुत अच्छा होगा अगर यह memfsइकाई परीक्षण के लिए उपयोग करने की संभावना की पेशकश करेगा । यदि ऐसा नहीं होता :-( github.com/jprichardson/node-fs-extra/issues/274
schnatterer

31

कम करने का उपयोग करके हम सत्यापित कर सकते हैं कि क्या प्रत्येक पथ मौजूद है और यदि आवश्यक हो तो इसे बनाएं, इस तरह से मुझे लगता है कि इसका पालन करना आसान है। संपादित, धन्यवाद @Arvin, हमें उचित प्लेटफ़ॉर्म-विशिष्ट पथ खंड विभाजक प्राप्त करने के लिए path.sep का उपयोग करना चाहिए।

const path = require('path');

// Path separators could change depending on the platform
const pathToCreate = 'path/to/dir'; 
pathToCreate
 .split(path.sep)
 .reduce((prevPath, folder) => {
   const currentPath = path.join(prevPath, folder, path.sep);
   if (!fs.existsSync(currentPath)){
     fs.mkdirSync(currentPath);
   }
   return currentPath;
 }, '');

4
उत्तर देते समय कुछ स्पष्टीकरण देना बेहतर होता है क्योंकि आपका उत्तर एक है।
स्टीफन राऊच

क्षमा करें, आप सही हैं, मुझे लगता है कि यह इस तरह से क्लीनर और पालन करने में आसान है
josebui

4
@josebui मुझे लगता है कि पर्यावरण स्फ़ेक्स के मुद्दों से बचने के लिए फॉरवर्ड स्लैश (/) के बजाय "path.sep" का उपयोग करना बेहतर है।
अरविन

अच्छा समाधान क्योंकि अन्य उत्तरों की तरह नोड> = 10 की आवश्यकता नहीं है
करीम

29

इस सुविधा को संस्करण 10.12.0 में नोड.जेएस में जोड़ा गया है, इसलिए यह कॉल के {recursive: true}लिए दूसरे तर्क के रूप में एक विकल्प को पारित करने के रूप में आसान है fs.mkdir()आधिकारिक डॉक्स में उदाहरण देखें ।

बाहरी मॉड्यूल या अपने स्वयं के कार्यान्वयन के लिए कोई ज़रूरत नहीं है।


1
मुझे संबंधित पुल अनुरोध github.com/nodejs/node/pull/23313
nurettin

1
जब निर्देशिका मौजूद होती है और बंद हो जाती है तो यह त्रुटि करेगा। किसी अन्य गैर-मौजूद फ़ोल्डर को बनाते रहने के लिए एक कोशिश पकड़ने वाले ब्लॉक का उपयोग करें।
चोको ली

1
यह स्वीकृत उत्तर होना चाहिए। यदि निर्देशिका पहले से मौजूद है, तो यह फेंकता नहीं है और इसका उपयोग async / fitpromises.mkdir के माध्यम से किया जा सकता है।
रिच अपाकाका

7

मुझे पता है कि यह एक पुराना प्रश्न है, लेकिन नोडज v10.12.0 अब इसे मूल रूप recursiveसे सच के विकल्प के साथ समर्थन करता है। fs.mkdir

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


2

विंडोज के लिए उदाहरण (कोई अतिरिक्त निर्भरता और त्रुटि से निपटने)

const path = require('path');
const fs = require('fs');

let dir = "C:\\temp\\dir1\\dir2\\dir3";

function createDirRecursively(dir) {
    if (!fs.existsSync(dir)) {        
        createDirRecursively(path.join(dir, ".."));
        fs.mkdirSync(dir);
    }
}

createDirRecursively(dir); //creates dir1\dir2\dir3 in C:\temp

2

आप बस फ़ोल्डर की मौजूदगी की जाँच कर सकते हैं या पथ में पुनरावृत्ति नहीं कर सकते हैं और फ़ोल्डर की जाँच करें जैसे कि वे मौजूद नहीं हैं। ( कोई बाहरी पुस्तकालय )

function checkAndCreateDestinationPath (fileDestination) {
    const dirPath = fileDestination.split('/');
    dirPath.forEach((element, index) => {
        if(!fs.existsSync(dirPath.slice(0, index + 1).join('/'))){
            fs.mkdirSync(dirPath.slice(0, index + 1).join('/')); 
        }
    });
}

2

आप अगले फ़ंक्शन का उपयोग कर सकते हैं

const recursiveUpload = (पथ: स्ट्रिंग) => {const पथ = path.split ("/")

const fullPath = paths.reduce((accumulator, current) => {
  fs.mkdirSync(accumulator)
  return `${accumulator}/${current}`
  })

  fs.mkdirSync(fullPath)

  return fullPath
}

तो यह क्या करता है:

  1. pathsवैरिएबल बनाएं , जहां यह ऐरे के एक तत्व के रूप में हर पथ को संग्रहीत करता है।
  2. सरणी में प्रत्येक तत्व के अंत में "/" जोड़ता है।
  3. चक्र के लिए बनाता है:
    1. सरणी तत्वों के अनुक्रमण से एक निर्देशिका बनाता है जो अनुक्रमित 0 से वर्तमान पुनरावृत्ति के लिए हैं। मूल रूप से, यह पुनरावर्ती है।

उम्मीद है की वो मदद करदे!

वैसे, नोड v10.12.0 में आप इसे अतिरिक्त तर्क के रूप में देकर पुनरावर्ती पथ निर्माण का उपयोग कर सकते हैं।

fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => { if (err) throw err; });

https://nodejs.org/api/fs.html#fs_fs_mkdirsync_path_options


1

बहुत से उत्तर, लेकिन यहाँ पुनरावृत्ति के बिना एक समाधान है जो पथ को विभाजित करके काम करता है और फिर बाएं से दाएं भवन को फिर से वापस बनाता है

function mkdirRecursiveSync(path) {
    let paths = path.split(path.delimiter);
    let fullPath = '';
    paths.forEach((path) => {

        if (fullPath === '') {
            fullPath = path;
        } else {
            fullPath = fullPath + '/' + path;
        }

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

विंडोज़ बनाम लिनक्स कम्पेटिबिलिटी के बारे में चिंतित लोगों के लिए, बस आगे की स्लैश को डबल बैकस्लैश '\' के साथ बदलें, दोनों ही घटनाओं में, लेकिन टीबीएच हम नोड कमांड के बारे में बात कर रहे हैं, विंडोज़ कमांड लाइन नहीं है और पूर्व में बहुत क्षमा है और उपरोक्त कोड बस काम करेगा विंडोज और अधिक पूर्ण समाधान पार मंच है।


खिड़कियों पर फाइलें बैकस्लैश के साथ हैंडल की जाती हैं, आगे की स्लैश नहीं। आपका कोड बस वहां काम नहीं करेगा। C: \ data \ test ...
DDD

संपादित लेकिन सुझाव है कि आप अपनी टिप्पणी को मान्य करते हैं। नोड पर निम्नलिखित का प्रयास करें और देखें कि क्या होता है var fs = आवश्यकता ('fs') fs.mkdirSync ('test') fs.mkdirSync ('test \\ test1') fs.mkdirSync ('test / test2')
Hamiora

आप जो कुछ भी कह रहे हैं .., मेरा डाउन वोट तब तक रहता है जब तक आप बेहतर कोड लिखना नहीं सीखते।
DDD

Haha। ठीक है, मैं बेहतर कोड लिखने के लिए सीखने पर वास्तव में कड़ी मेहनत करूंगा। बीपीडब्ल्यू सबसे ऊपर, ओपी सहित, आगे के स्लैश का उपयोग करता है। सुझाव है कि आप ट्रोलिंग बंद करो।
हमीर जू

1
path.sepमेरे लिए या तो / या \\ के माध्यम से आ रहा है। path.delimiterहै: या ?;
जोश एंडरसन स्लेट

1
const fs = require('fs');

try {
    fs.mkdirSync(path, { recursive: true });
} catch (error) {
    // this make script keep running, even when folder already exist
    console.log(error);
}

0

निर्देशिकाओं को पुनरावर्ती बनाने के लिए एक अतुल्यकालिक तरीका:

import fs from 'fs'

const mkdirRecursive = function(path, callback) {
  let controlledPaths = []
  let paths = path.split(
    '/' // Put each path in an array
  ).filter(
    p => p != '.' // Skip root path indicator (.)
  ).reduce((memo, item) => {
    // Previous item prepended to each item so we preserve realpaths
    const prevItem = memo.length > 0 ? memo.join('/').replace(/\.\//g, '')+'/' : ''
    controlledPaths.push('./'+prevItem+item)
    return [...memo, './'+prevItem+item]
  }, []).map(dir => {
    fs.mkdir(dir, err => {
      if (err && err.code != 'EEXIST') throw err
      // Delete created directory (or skipped) from controlledPath
      controlledPaths.splice(controlledPaths.indexOf(dir), 1)
      if (controlledPaths.length === 0) {
        return callback()
      }
    })
  })
}

// Usage
mkdirRecursive('./photos/recent', () => {
  console.log('Directories created succesfully!')
})

0

यहाँ mkdirpनोडज के लिए मेरा अनिवार्य संस्करण है ।

function mkdirSyncP(location) {
    let normalizedPath = path.normalize(location);
    let parsedPathObj = path.parse(normalizedPath);
    let curDir = parsedPathObj.root;
    let folders = parsedPathObj.dir.split(path.sep);
    folders.push(parsedPathObj.base);
    for(let part of folders) {
        curDir = path.join(curDir, part);
        if (!fs.existsSync(curDir)) {
            fs.mkdirSync(curDir);
        }
    }
}

0

इस दृष्टिकोण के बारे में कैसे:

if (!fs.existsSync(pathToFile)) {
            var dirName = "";
            var filePathSplit = pathToFile.split('/');
            for (var index = 0; index < filePathSplit.length; index++) {
                dirName += filePathSplit[index]+'/';
                if (!fs.existsSync(dirName))
                    fs.mkdirSync(dirName);
            }
        }

यह सापेक्ष पथ के लिए काम करता है।


0

मौनी के शून्य-निर्भरता के उत्तर के आधार पर , यहां Typescriptमॉड्यूल के रूप में थोड़ा अधिक शुरुआती अनुकूल संस्करण है:

import * as fs from 'fs';
import * as path from 'path';

/**
* Recursively creates directories until `targetDir` is valid.
* @param targetDir target directory path to be created recursively.
* @param isRelative is the provided `targetDir` a relative path?
*/
export function mkdirRecursiveSync(targetDir: string, isRelative = false) {
    const sep = path.sep;
    const initDir = path.isAbsolute(targetDir) ? sep : '';
    const baseDir = isRelative ? __dirname : '.';

    targetDir.split(sep).reduce((prevDirPath, dirToCreate) => {
        const curDirPathToCreate = path.resolve(baseDir, prevDirPath, dirToCreate);
        try {
            fs.mkdirSync(curDirPathToCreate);
        } catch (err) {
            if (err.code !== 'EEXIST') {
                throw err;
            }
            // caught EEXIST error if curDirPathToCreate already existed (not a problem for us).
        }

        return curDirPathToCreate; // becomes prevDirPath on next call to reduce
    }, initDir);
}

0

इस रूप में साफ :)

function makedir(fullpath) {
  let destination_split = fullpath.replace('/', '\\').split('\\')
  let path_builder = destination_split[0]
  $.each(destination_split, function (i, path_segment) {
    if (i < 1) return true
    path_builder += '\\' + path_segment
    if (!fs.existsSync(path_builder)) {
      fs.mkdirSync(path_builder)
    }
  })
}

0

मेरे पास fs.mkdir के पुनरावर्ती विकल्प के साथ समस्याएं थीं, इसलिए मैंने एक फ़ंक्शन बनाया जो निम्न कार्य करता है:

  1. अंतिम लक्ष्य dir और मूल माता-पिता के साथ काम करते हुए, सभी निर्देशिकाओं की एक सूची बनाता है।
  2. कार्य करने के लिए mkdir फ़ंक्शन के लिए आवश्यक निर्देशिकाओं की एक नई सूची बनाता है
  3. फाइनल सहित प्रत्येक निर्देशिका की जरूरत है

    function createDirectoryIfNotExistsRecursive(dirname) {
        return new Promise((resolve, reject) => {
           const fs = require('fs');
    
           var slash = '/';
    
           // backward slashes for windows
           if(require('os').platform() === 'win32') {
              slash = '\\';
           }
           // initialize directories with final directory
           var directories_backwards = [dirname];
           var minimize_dir = dirname;
           while (minimize_dir = minimize_dir.substring(0, minimize_dir.lastIndexOf(slash))) {
              directories_backwards.push(minimize_dir);
           }
    
           var directories_needed = [];
    
           //stop on first directory found
           for(const d in directories_backwards) {
              if(!(fs.existsSync(directories_backwards[d]))) {
                 directories_needed.push(directories_backwards[d]);
              } else {
                 break;
              }
           }
    
           //no directories missing
           if(!directories_needed.length) {
              return resolve();
           }
    
           // make all directories in ascending order
           var directories_forwards = directories_needed.reverse();
    
           for(const d in directories_forwards) {
              fs.mkdirSync(directories_forwards[d]);
           }
    
           return resolve();
        });
     }

-1

Exec खिड़कियों पर गन्दा हो सकता है। एक और "नोडी" समाधान है। मौलिक रूप से, आपके पास एक पुनरावर्ती कॉल है यह देखने के लिए कि क्या कोई निर्देशिका मौजूद है और बच्चे में गोता लगाएँ (यदि यह मौजूद है) या इसे बनाएं। यहां एक फ़ंक्शन है जो बच्चों को बनाएगा और समाप्त होने पर फ़ंक्शन को कॉल करेगा:

fs = require('fs');
makedirs = function(path, func) {
 var pth = path.replace(/['\\]+/g, '/');
 var els = pth.split('/');
 var all = "";
 (function insertOne() {
   var el = els.splice(0, 1)[0];
   if (!fs.existsSync(all + el)) {
    fs.mkdirSync(all + el);
   }
   all += el + "/";
   if (els.length == 0) {
    func();
   } else {
     insertOne();
   }
   })();

}


-1

यह संस्करण शीर्ष उत्तर की तुलना में विंडोज पर बेहतर काम करता है क्योंकि यह दोनों को समझता है /और path.sepइसलिए कि आगे की स्लैश विंडोज पर काम करना चाहिए जैसा कि उन्हें करना चाहिए। पूर्ण और सापेक्ष पथ (सापेक्ष process.cwd) का समर्थन करता है ।

/**
 * Creates a folder and if necessary, parent folders also. Returns true
 * if any folders were created. Understands both '/' and path.sep as 
 * path separators. Doesn't try to create folders that already exist,
 * which could cause a permissions error. Gracefully handles the race 
 * condition if two processes are creating a folder. Throws on error.
 * @param targetDir Name of folder to create
 */
export function mkdirSyncRecursive(targetDir) {
  if (!fs.existsSync(targetDir)) {
    for (var i = targetDir.length-2; i >= 0; i--) {
      if (targetDir.charAt(i) == '/' || targetDir.charAt(i) == path.sep) {
        mkdirSyncRecursive(targetDir.slice(0, i));
        break;
      }
    }
    try {
      fs.mkdirSync(targetDir);
      return true;
    } catch (err) {
      if (err.code !== 'EEXIST') throw err;
    }
  }
  return false;
}

क्या विंडोज को सही तरीके से सपोर्ट करने के लिए डाउनवोट था? क्या मैंने इसका उल्लेख अन्य OS पर भी काम किया है?
Qwertie
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.