जवाबों:
var fs = require('fs');
var dir = './tmp';
if (!fs.existsSync(dir)){
fs.mkdirSync(dir);
}Syncविधियों का उपयोग करना आम तौर पर एक नहीं-नहीं है: इवेंट लूप को ब्लॉक नहीं करना चाहते
नहीं, कई कारणों से।
pathमॉड्यूल एक भी नहीं है exists/ existsSyncविधि। यह fsमॉड्यूल में है। (शायद आपने अपने प्रश्न में केवल एक टाइपो बनाया है?)
डॉक्स स्पष्ट रूप से आपको उपयोग करने से हतोत्साहित करता हैexists ।
fs.exists()एक ऐतिहासिकता है और केवल ऐतिहासिक कारणों से मौजूद है। अपने कोड में इसका उपयोग करने का कोई कारण नहीं होना चाहिए।विशेष रूप से, पता चल सके कि उद्घाटन से पहले एक फ़ाइल मौजूद है यह एक विरोधी पैटर्न है कि पत्ते आप दौड़ की स्थिति के लिए असुरक्षित है: किसी अन्य प्रक्रिया के लिए कॉल के बीच फ़ाइल निकाल सकते हैं
fs.exists()औरfs.open()। बस फ़ाइल खोलें और जब यह नहीं है तो त्रुटि को संभालें।
चूंकि हम एक फ़ाइल के बजाय एक निर्देशिका के बारे में बात कर रहे हैं, इस सलाह का अर्थ है कि आपको बिना शर्त कॉल करना चाहिए mkdirऔर अनदेखा करना चाहिए EEXIST।
सामान्य तौर पर, आपको * से बचना चाहिएSync विधियों । वे अवरुद्ध कर रहे हैं, जिसका अर्थ है कि डिस्क पर जाते समय आपके कार्यक्रम में कुछ और नहीं हो सकता है। यह एक बहुत ही महंगा ऑपरेशन है, और इसमें लगने वाला समय नोड के ईवेंट लूप की मुख्य धारणा को तोड़ता है।
* Syncविधियाँ आमतौर पर एकल-उद्देश्य वाली त्वरित लिपियों में ठीक होती हैं (जो एक काम करती हैं और फिर बाहर निकलती हैं), लेकिन जब आप सर्वर लिख रहे हों तो इसका उपयोग कभी नहीं किया जाना चाहिए: आपका सर्वर पूरी अवधि के लिए किसी का भी जवाब देने में असमर्थ होगा। I / O अनुरोधों की। यदि कई क्लाइंट अनुरोधों के लिए I / O संचालन की आवश्यकता होती है, तो आपका सर्वर बहुत जल्दी रुक जाएगा।
Syncएक सर्वर अनुप्रयोग में * विधियों का उपयोग करने के बारे में विचार करने का एकमात्र समय मैं स्टार्टअप में एक बार (और केवल एक बार) होता है । उदाहरण के लिए, require वास्तव मेंreadFileSync मॉड्यूल लोड करने के लिए उपयोग करता है।
फिर भी, आपको अभी भी सावधान रहना होगा क्योंकि बहुत सारे सिंक्रोनस I / O अनावश्यक रूप से आपके सर्वर के स्टार्टअप समय को धीमा कर सकते हैं।
इसके बजाय, आपको एसिंक्रोनस I / O विधियों का उपयोग करना चाहिए।
इसलिए अगर हम सलाह के उन टुकड़ों को एक साथ रखते हैं, तो हमें कुछ ऐसा मिलता है:
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
});
}और हम इसे इस तरह से उपयोग कर सकते हैं:
ensureExists(__dirname + '/upload', 0744, function(err) {
if (err) // handle folder creation error
else // we're all good
});बेशक, यह किनारे के मामलों की तरह नहीं है
0744 == 484।
मैंने पाया है और npm मॉड्यूल जो इसके लिए एक आकर्षण की तरह काम करता है। यह बस जरूरत पड़ने पर एक पुनरावर्ती mkdir करता है, जैसे "mkdir -p"।
इस mkdirपद्धति में किसी भी निर्देशिका को पुनरावृत्ति करने की क्षमता है जो मौजूद नहीं है, और जो करते हैं उसे अनदेखा करें।
से नोड v10 / 11 डॉक्स :
// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.
fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
if (err) throw err;
});नोट: आपको fsपहले निर्मित मॉड्यूल आयात करना होगा ।
अब यहाँ एक और अधिक मजबूत उदाहरण है जो मूल ES मॉड्यूल (ध्वज सक्षम और .mjs एक्सटेंशन के साथ) का लाभ उठाता है, गैर-रूट पथ को संभालता है, और पूर्ण पथनामों के लिए खाता है:
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');
}
});
}आप इसका उपयोग कर सकते हैं createDirectories('/components/widget/widget.js');।
और निश्चित रूप से, आप संभवतः निर्देशिकाओं का निर्माण करते समय अधिक पठनीय सिंक्रोनस-लुकिंग तरीके से फ़ाइल निर्माण का लाभ उठाने के लिए async / प्रतीक्षा के साथ वादों का उपयोग करके अधिक फैंसी प्राप्त करना चाहेंगे; लेकिन, यह सवाल के दायरे से परे है।
बस किसी एक लाइन संस्करण में रुचि रखने वाले के मामले में। :)
//or in typescript: import * as fs from 'fs';
const fs = require('fs');
!fs.existsSync(dir) && fs.mkdirSync(dir);mkdirयदि फ़ोल्डर मौजूद है, तो आप बस त्रुटि का उपयोग और पकड़ सकते हैं ।
यह async (इतना अच्छा अभ्यास) और सुरक्षित है।
fs.mkdir('/path', err => {
if (err && err.code != 'EEXIST') throw 'up'
.. safely do your stuff here
})(वैकल्पिक रूप से मोड के साथ दूसरा तर्क जोड़ें।)
अन्य विचार:
आप तब उपयोग कर सकते थे या देशी प्रॉमिस का उपयोग करके इंतजार कर सकते थे ।
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() })आप अपना खुद का वादा विधि बना सकते हैं, कुछ इस तरह (अप्रकाशित):
let mkdirAsync = (path, mode) => new Promise(
(resolve, reject) => mkdir (path, mode,
err => (err && err.code !== 'EEXIST') ? reject(err) : resolve()
)
)तुल्यकालिक जाँच के लिए, आप उपयोग कर सकते हैं:
fs.existsSync(path) || fs.mkdirSync(path)या आप एक पुस्तकालय का उपयोग कर सकते हैं, दो सबसे लोकप्रिय जा रहा है
mkdir('/path').catch(err => { if (err.code != 'EEXIST') throw err;}).then(myFunc);
!==इसके बजाय का उपयोग करें!=
साथ FS-अतिरिक्त पैकेज आप के साथ ऐसा कर सकते हैं एक एक लाइनर :
const fs = require('fs-extra');
const dir = '/tmp/this/path/does/not/exist';
fs.ensureDirSync(dir);सबसे अच्छा समाधान नोड-एफएस-एक्सट्रा नामक एनपीएम मॉड्यूल का उपयोग करना होगा । इसमें एक विधि है, mkdirजो आपके द्वारा उल्लिखित निर्देशिका बनाता है। यदि आप एक लंबी निर्देशिका पथ देते हैं, तो यह स्वचालित रूप से मूल फ़ोल्डर बना देगा। मॉड्यूल npm मॉड्यूल का एक सुपर सेट है fs, इसलिए fsयदि आप इस मॉड्यूल को जोड़ते हैं , तो आप सभी फ़ंक्शन का उपयोग कर सकते हैं ।
var dir = 'path/to/dir';
try {
fs.mkdirSync(dir);
} catch(e) {
if (e.code != 'EEXIST') throw e;
}Apr 2018: नोडज्स.ओआरपी ./api/fs.html#fs_fs_existssync_path
var filessystem = require('fs');
var dir = './path/subpath/';
if (!filessystem.existsSync(dir)){
filessystem.mkdirSync(dir);
}else
{
console.log("Directory already exist");
}इससे आपको मदद मिल सकती है :)
ENOENT: ऐसी कोई फ़ाइल या निर्देशिका नहीं है
समाधान
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 के उत्तर का एक टाइपस्क्रिप्ट प्रॉमिस रिफैक्टर जोड़ना चाहूंगा ।
यह एक ही काम करता है और एक ही किनारे के मामले हैं, यह सिर्फ वादों, टाइपस्क्रिप्ट टाइप का उपयोग करने के लिए होता है और "सख्त से सख्त" काम करता है।
// 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
}
});
});
}नोड 10 + ईएस 6 के साथ:
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;
}
}
})();आप कॉल फ़ाइल सिस्टम कमांड fs.stat का उपयोग यह जांचने के लिए कर सकते हैं कि क्या dir मौजूद है और fs.mkdir कॉलबैक के साथ निर्देशिका बनाने के लिए, या fs.mkdirSync कॉलबैक के बिना एक निर्देशिका बनाने के लिए, इस उदाहरण की तरह:
//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);
}
});
};यहाँ पुनरावर्ती निर्देशिका बनाने का एक छोटा सा कार्य है:
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 / प्रतीक्षा का उपयोग करना:
const mkdirP = async (directory) => {
try {
return await fs.mkdirAsync(directory);
} catch (error) {
if (error.code != 'EEXIST') {
throw e;
}
}
};आपको प्रॉमिस करना होगा fs:
import nodeFs from 'fs';
import bluebird from 'bluebird';
const fs = bluebird.promisifyAll(nodeFs);