मुझे नोड के सभी फ़ोल्डर में नोड की आवश्यकता कैसे है।
कुछ इस तरह की जरूरत है:
files.forEach(function (v,k){
// require routes
require('./routes/'+v);
}};
मुझे नोड के सभी फ़ोल्डर में नोड की आवश्यकता कैसे है।
कुछ इस तरह की जरूरत है:
files.forEach(function (v,k){
// require routes
require('./routes/'+v);
}};
जवाबों:
जब आवश्यकता होती है एक फ़ोल्डर का रास्ता दिया जाता है, यह उस फ़ोल्डर में एक index.js फ़ाइल की तलाश करेगा; यदि कोई है, तो वह इसका उपयोग करता है, और यदि ऐसा नहीं है, तो यह विफल रहता है।
यह संभवत: सबसे अधिक समझ में आता है (यदि आपके पास फ़ोल्डर पर नियंत्रण है) एक index.js फ़ाइल बनाने के लिए और फिर सभी "मॉड्यूल" असाइन करें और फिर बस इसकी आवश्यकता है।
yourfile.js
var routes = require("./routes");index.js
exports.something = require("./routes/something.js");
exports.others = require("./routes/others.js");
यदि आपको नहीं पता है कि फ़ाइल नाम आपको लोडर के कुछ प्रकार लिखने चाहिए।
लोडर का कार्य उदाहरण:
var normalizedPath = require("path").join(__dirname, "routes");
require("fs").readdirSync(normalizedPath).forEach(function(file) {
require("./routes/" + file);
});
// Continue application logic here
requireकिसी फ़ोल्डर का पथ दिया जाता है, तो वह index.jsउस फ़ोल्डर में खोज करेगा; यदि कोई है, तो वह इसका उपयोग करता है, और यदि ऐसा नहीं है, तो यह विफल रहता है। इस की वास्तविक दुनिया के उदाहरण के लिए github.com/christkv/node-mongodb-native देखें : index.jsरूट निर्देशिका में ./lib/mongodbएक की आवश्यकता है जो एक निर्देशिका की आवश्यकता है ; ./lib/mongodb/index.js'उस निर्देशिका में बाकी सब कुछ उपलब्ध करता है।
requireएक तुल्यकालिक कार्य है, इसलिए कॉलबैक से कोई लाभ नहीं है। मैं इसके बजाय fs.readdirSync का उपयोग करूंगा।
package.jsonको इस डायरेक्टरी में बदल दिया जा सकता है । जैसे:{main: './lib/my-custom-main-file.js'}
मैं उस कार्य को पूरा करने के लिए ग्लोब का उपयोग करने की सलाह देता हूं ।
var glob = require( 'glob' )
, path = require( 'path' );
glob.sync( './routes/**/*.js' ).forEach( function( file ) {
require( path.resolve( file ) );
});
glob? तुम्हारा मतलब है glob-savior-of-the-nodejs-race। सबसे बढ़िया उत्तर।
@ Tbranyen के समाधान के आधार पर, मैं एक index.jsफ़ाइल बनाता हूं जो वर्तमान फ़ोल्डर के तहत मनमाने ढंग से जावास्क्रिप्ट को लोड करता है exports।
// Load `*.js` under current directory as properties
// i.e., `User.js` will become `exports['User']` or `exports.User`
require('fs').readdirSync(__dirname + '/').forEach(function(file) {
if (file.match(/\.js$/) !== null && file !== 'index.js') {
var name = file.replace('.js', '');
exports[name] = require('./' + file);
}
});
फिर आप requireइस निर्देशिका को किसी अन्य स्थान से कर सकते हैं ।
एक अन्य विकल्प पैकेज रिक्वायरमेंट-डीआईआर का उपयोग करना है जो आप निम्नलिखित करते हैं। यह पुनरावृत्ति का भी समर्थन करता है।
var requireDir = require('require-dir');
var dir = requireDir('./path/to/dir');
require-dirक्योंकि यह स्वचालित रूप से कॉलिंग फ़ाइल (इंडेक्स) और वर्तमान निर्देशिका में डिफ़ॉल्ट को बाहर कर देता है। उत्तम।
require-dirएक filterविकल्प जोड़ा गया ।
मेरे पास एक एकल, प्रत्येक वर्ग के साथ फ़ाइलों से भरा एक फ़ोल्डर / फ़ील्ड है:
fields/Text.js -> Test class
fields/Checkbox.js -> Checkbox class
प्रत्येक वर्ग को निर्यात करने के लिए इसे खेतों / index.js में छोड़ें:
var collectExports, fs, path,
__hasProp = {}.hasOwnProperty;
fs = require('fs');
path = require('path');
collectExports = function(file) {
var func, include, _results;
if (path.extname(file) === '.js' && file !== 'index.js') {
include = require('./' + file);
_results = [];
for (func in include) {
if (!__hasProp.call(include, func)) continue;
_results.push(exports[func] = include[func]);
}
return _results;
}
};
fs.readdirSync('./fields/').forEach(collectExports);
यह मॉड्यूल को अधिक कार्य करता है जैसे कि वे पायथन में होंगे:
var text = new Fields.Text()
var checkbox = new Fields.Checkbox()
सबसे लोकप्रिय पैकेजों में से एक और विकल्प की आवश्यकता है- dir-all संयोजन सुविधाएँ।
अधिकांश लोकप्रिय के require-dirपास फ़ाइलों / डीआईआर को फ़िल्टर करने के लिए विकल्प नहीं होते हैं और mapफ़ंक्शन नहीं होते हैं (नीचे देखें), लेकिन मॉड्यूल के वर्तमान पथ को खोजने के लिए छोटी चाल का उपयोग करता है।
लोकप्रियता से दूसरे require-allमें रीजेक्सप फ़िल्टरिंग और प्रीप्रोसेसिंग है, लेकिन रिश्तेदार पथ का अभाव है, इसलिए आपको उपयोग करने की आवश्यकता है __dirname(इसमें पेशेवरों और विपरीत) जैसे:
var libs = require('require-all')(__dirname + '/lib');यहाँ उल्लेख किया गया require-indexहै काफी न्यूनतर है।
साथ mapआप कुछ पूर्व प्रसंस्करण कर सकते हैं, जैसे वस्तुओं को बनाने और config मान (निर्यात कंस्ट्रक्टर्स नीचे मॉड्यूल कल्पना करते हुए) पारित:
// Store config for each module in config object properties
// with property names corresponding to module names
var config = {
module1: { value: 'config1' },
module2: { value: 'config2' }
};
// Require all files in modules subdirectory
var modules = require('require-dir-all')(
'modules', // Directory to require
{ // Options
// function to be post-processed over exported object for each require'd module
map: function(reqModule) {
// create new object with corresponding config passed to constructor
reqModule.exports = new reqModule.exports( config[reqModule.name] );
}
}
);
// Now `modules` object holds not exported constructors,
// but objects constructed using values provided in `config`.
मुझे पता है कि यह प्रश्न 5+ वर्ष पुराना है, और दिए गए उत्तर अच्छे हैं, लेकिन मैं एक्सप्रेस के लिए कुछ अधिक शक्तिशाली चाहता था, इसलिए मैंने express-map2npm के लिए पैकेज बनाया । मैं इसे बस नाम देने जा रहा था express-map, हालांकि याहू में लोगों के पास पहले से ही इस नाम का एक पैकेज है, इसलिए मुझे अपने पैकेज का नाम बदलना पड़ा।
1. बुनियादी उपयोग:
app.js (or whatever you call it)
var app = require('express'); // 1. include express
app.set('controllers',__dirname+'/controllers/');// 2. set path to your controllers.
require('express-map2')(app); // 3. patch map() into express
app.map({
'GET /':'test',
'GET /foo':'middleware.foo,test',
'GET /bar':'middleware.bar,test'// seperate your handlers with a comma.
});
नियंत्रक उपयोग:
//single function
module.exports = function(req,res){
};
//export an object with multiple functions.
module.exports = {
foo: function(req,res){
},
bar: function(req,res){
}
};
2. उपसर्गों के साथ उन्नत उपयोग:
app.map('/api/v1/books',{
'GET /': 'books.list', // GET /api/v1/books
'GET /:id': 'books.loadOne', // GET /api/v1/books/5
'DELETE /:id': 'books.delete', // DELETE /api/v1/books/5
'PUT /:id': 'books.update', // PUT /api/v1/books/5
'POST /': 'books.create' // POST /api/v1/books
});
जैसा कि आप देख सकते हैं, यह एक टन समय बचाता है और आपके एप्लिकेशन की रूटिंग को लिखने, बनाए रखने और समझने के लिए मृत बनाता है। यह उन सभी HTTP क्रियाओं का समर्थन करता है जो समर्थन व्यक्त करती हैं, साथ ही विशेष .all()विधि भी।
एक मॉड्यूल जिसे मैं इस सटीक उपयोग के मामले के लिए उपयोग कर रहा हूं, वह सभी की आवश्यकता है ।
जब तक वे excludeDirsसंपत्ति से मेल नहीं खाते तब तक किसी दिए गए निर्देशिका और उसके उप निर्देशिका में सभी फ़ाइलों की आवश्यकता होती है ।
यह फ़ाइल फ़िल्टर को निर्दिष्ट करने और फ़ाइल नाम से दिए गए हैश की कुंजियों को कैसे प्राप्त करने की अनुमति देता है।
मैं नोड फाइल कॉपी-टू-मॉड्यूल का उपयोग कर रहा हूं ताकि हमारे NodeJS- आधारित सिस्टम में सभी फाइलों की आवश्यकता हो।
हमारी उपयोगिता फ़ाइल का कोड इस तरह दिखता है:
/**
* Module dependencies.
*/
var copy = require('copy-to');
copy(require('./module1'))
.and(require('./module2'))
.and(require('./module3'))
.to(module.exports);सभी फ़ाइलों में, अधिकांश कार्यों को निर्यात के रूप में लिखा जाता है, जैसे:
exports.function1 = function () { // function contents };
exports.function2 = function () { // function contents };
exports.function3 = function () { // function contents };तो, किसी फ़ाइल से किसी फ़ंक्शन का उपयोग करने के लिए, आप बस कॉल करें:
var utility = require('./utility');
var response = utility.function2(); // or whatever the name of the function isइस glob समाधान पर विस्तार । यदि आप एक निर्देशिका से सभी मॉड्यूल को आयात करना चाहते हैं index.jsऔर फिर index.jsआवेदन के दूसरे भाग में आयात करें । ध्यान दें कि टेम्पलेट शाब्दिक स्टैकओवरफ़्लो द्वारा उपयोग किए गए हाइलाइटिंग इंजन द्वारा समर्थित नहीं हैं, इसलिए कोड यहां अजीब लग सकता है।
const glob = require("glob");
let allOfThem = {};
glob.sync(`${__dirname}/*.js`).forEach((file) => {
/* see note about this in example below */
allOfThem = { ...allOfThem, ...require(file) };
});
module.exports = allOfThem;पूर्ण उदाहरण
निर्देशिका संरचना
globExample/example.js
globExample/foobars/index.js
globExample/foobars/unexpected.js
globExample/foobars/barit.js
globExample/foobars/fooit.jsglobExample / example.js
const { foo, bar, keepit } = require('./foobars/index');
const longStyle = require('./foobars/index');
console.log(foo()); // foo ran
console.log(bar()); // bar ran
console.log(keepit()); // keepit ran unexpected
console.log(longStyle.foo()); // foo ran
console.log(longStyle.bar()); // bar ran
console.log(longStyle.keepit()); // keepit ran unexpectedglobExample / foobars / index.js
const glob = require("glob");
/*
Note the following style also works with multiple exports per file (barit.js example)
but will overwrite if you have 2 exports with the same
name (unexpected.js and barit.js have a keepit function) in the files being imported. As a result, this method is best used when
your exporting one module per file and use the filename to easily identify what is in it.
Also Note: This ignores itself (index.js) by default to prevent infinite loop.
*/
let allOfThem = {};
glob.sync(`${__dirname}/*.js`).forEach((file) => {
allOfThem = { ...allOfThem, ...require(file) };
});
module.exports = allOfThem;globExample / foobars / unexpected.js
exports.keepit = () => 'keepit ran unexpected';globExample / foobars / barit.js
exports.bar = () => 'bar run';
exports.keepit = () => 'keepit ran';globExample / foobars / fooit.js
exports.foo = () => 'foo ran';glob स्थापित , चलाने के साथ अंदर की परियोजना सेnode example.js
$ node example.js
foo ran
bar run
keepit ran unexpected
foo ran
bar run
keepit ran unexpectedउपयोग कर सकते हैं: https://www.npmjs.com/package/require-file-directory
routesफ़ोल्डर से सभी फ़ाइलों की आवश्यकता होती है और मिडलवेयर के रूप में लागू होती है। कोई बाहरी मॉड्यूल की जरूरत है।
// require
const path = require("path");
const { readdirSync } = require("fs");
// apply as middleware
readdirSync("./routes").map((r) => app.use("/api", require("./routes/" + r)));इस फ़ंक्शन का उपयोग करके आपको एक संपूर्ण डायर की आवश्यकता हो सकती है।
const GetAllModules = ( dirname ) => {
if ( dirname ) {
let dirItems = require( "fs" ).readdirSync( dirname );
return dirItems.reduce( ( acc, value, index ) => {
if ( PATH.extname( value ) == ".js" && value.toLowerCase() != "index.js" ) {
let moduleName = value.replace( /.js/g, '' );
acc[ moduleName ] = require( `${dirname}/${moduleName}` );
}
return acc;
}, {} );
}
}
// calling this function.
let dirModules = GetAllModules(__dirname);यदि आप निर्देशिका उदाहरण में ".js की सभी फ़ाइलें (" एप्लिकेशन / लीबी / *। Js ") शामिल करते हैं।
example.js:
module.exports = function (example) { }उदाहरण-2.js:
module.exports = function (example2) { }index.js:
module.exports = require('./app/lib');
var routes = require('auto-load')('routes');नएauto-loadमॉड्यूल के साथ [मैंने इसे बनाने में मदद की]।