Node.js में, मैं अपनी अन्य फ़ाइलों से "कार्यों" को कैसे शामिल करूं?

Question

चलो मैं एक फ़ाइल बुलाया app.js. है कहना बहुत साधारण:

var express = require('express');
var app = express.createServer();
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');
app.get('/', function(req, res){
  res.render('index', {locals: {
    title: 'NowJS + Express Example'
  }});
});

app.listen(8080);

क्या होगा अगर मेरे पास "tools.js" के अंदर एक फ़ंक्शन है। मैं उन्हें apps.js में उपयोग करने के लिए कैसे आयात करूंगा?

या ... क्या मुझे "टूल" को एक मॉड्यूल में बदलना है, और फिर इसकी आवश्यकता है? << कठिन लगता है, मैं बल्कि tools.js फ़ाइल के मूल आयात करते हैं।

Comments

क्या मुझे यहाँ फेंक दिया requireविंडोज पर उसी निर्देशिका में एक फ़ोल्डर आईएनजी था । आपको यूनिक्स शैली के पते का उपयोग करने के लिए मिला है: ./mydirसादे पुराने के बजाय mydir।

— बेन

मैंने स्क्रिप्ट आयात करने, फ़ाइल निर्यात करने और बाहरी node_modulesफ़ोल्डर से मॉड्यूल शामिल करने के लिए एक मॉड्यूल बनाया । npmjs.com/package/node-import आशा है कि यह मदद कर सकता है। धन्यवाद!

— नानंग महाडेन एल-अगुंग

Answer 1

आपको किसी भी js फ़ाइल की आवश्यकता हो सकती है, आपको बस यह घोषित करने की आवश्यकता है कि आप क्या उजागर करना चाहते हैं।

// tools.js
// ========
module.exports = {
  foo: function () {
    // whatever
  },
  bar: function () {
    // whatever
  }
};

var zemba = function () {
}

और आपकी एप्लिकेशन फ़ाइल में:

// app.js
// ======
var tools = require('./tools');
console.log(typeof tools.foo); // => 'function'
console.log(typeof tools.bar); // => 'function'
console.log(typeof tools.zemba); // => undefined

Comments

+1 अच्छी तरह से किया गया, यहां तक ​​कि आयातित कोड को यह अपने नाम स्थान तक ही सीमित रखता है। मुझे बाद में इसके लिए एक नोट बनाना होगा।

— इवान प्लाइस

मुझे आश्चर्य है कि अगर बाहरी लिपियों को आयात करना संभव है। require("http://javascript-modules.googlecode.com/svn/functionChecker.js")मॉड्यूल को सही ढंग से आयात करना प्रतीत नहीं होता है। क्या बाहरी लिपियों को आयात करने का कोई और तरीका है?

— एंडरसन ग्रीन

और क्या होगा अगर मुझे वेरिएबल को फंक्शन में पास करना है जैसे, बार: फंक्शन (ए, बी) {// कुछ कोड}

— निशुतोष शर्मा

चूंकि आप संपत्तियों को उजागर कर रहे हैं इसलिए मैं मॉड्यूल के बजाय निर्यात का उपयोग करूंगा। निर्यात। निर्यात बनाम मॉड्यूल के लिए। निर्यात: stackoverflow.com/questions/5311334/…

— फार्म

फंक्शन बार () को कॉल कैसे करें, foo के अंदर () फंक्शन, का अर्थ है कि एक फंक्शन को दूसरे तक कैसे पहुँचा जाए

— pitu

Answer 2

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

var fs = require('fs');

// file is included here:
eval(fs.readFileSync('tools.js')+'');

• +''फ़ाइल सामग्री को स्ट्रिंग के रूप में प्राप्त करने के लिए खाली स्ट्रिंग संयोजन आवश्यक है और ऑब्जेक्ट नहीं ( .toString()यदि आप चाहें तो उपयोग कर सकते हैं)।
• निष्कासन () का उपयोग किसी फ़ंक्शन के अंदर नहीं किया जा सकता है और इसे वैश्विक दायरे के अंदर बुलाया जाना चाहिए अन्यथा कोई फ़ंक्शन या चर सुलभ नहीं होंगे (यानी आप एक include()उपयोगिता फ़ंक्शन या ऐसा कुछ नहीं बना सकते हैं )।

कृपया ध्यान दें कि ज्यादातर मामलों में यह खराब अभ्यास है और आपको इसके बजाय एक मॉड्यूल लिखना चाहिए । हालाँकि, ऐसी दुर्लभ स्थितियाँ हैं, जहाँ आपके स्थानीय संदर्भ / नामस्थान का प्रदूषण वही है जो आप वास्तव में चाहते हैं।

अपडेट 2015-08-06

कृपया यह भी ध्यान दें कि "use strict";जब आप "सख्त मोड" में हैं, तो यह काम नहीं करेगा क्योंकि "आयातित" फ़ाइल में परिभाषित फ़ंक्शन और चर आयात किए जाने वाले कोड तक नहीं पहुंच सकते हैं । सख्त मोड भाषा मानक के नए संस्करणों द्वारा परिभाषित कुछ नियमों को लागू करता है। यहाँ वर्णित समाधान से बचने का यह एक और कारण हो सकता है।

Comments

कूल, यह एक नोड-स्टाइल कांटा बनाए रखने की आवश्यकता के बिना एक नोड में जेएस के काम के लिए डिज़ाइन किए गए जेएस के कामों को त्वरित रूप से लागू करने के लिए उपयोगी है।

— कोस

मैंने बस मूल प्रश्न का उत्तर दिया, जो कोड सहित है, न कि मॉड्यूल लिखना। पूर्व में कुछ स्थितियों में फायदे हो सकते हैं। इसके अलावा, आपकी आवश्यकता के बारे में धारणा गलत है: कोड निश्चित रूप से स्पष्ट है, लेकिन यह अपने स्वयं के नामस्थान में रहता है और इसमें कॉलिंग संदर्भ के नाम स्थान को "प्रदूषित" करने का कोई तरीका नहीं है, इसलिए आपको इसे स्वयं () को खाली करने की आवश्यकता है। ज्यादातर मामलों में मेरे एवेन्यू में वर्णित विधि का उपयोग करना बुरा व्यवहार है लेकिन यह मुझे नहीं है कि यह तय करना चाहिए कि क्या यह टीआईएमईएक्स के लिए है।

— उडो जी

@EvanPlaice: क्या आपके पास एक बेहतर सुझाव है जो वास्तव में प्रश्न का उत्तर देता है ? यदि आपको एक फ़ाइल शामिल करने की आवश्यकता है जो एक मॉड्यूल नहीं है , तो क्या आपके पास इससे बेहतर तरीका है?

— ११:१२

कभी-कभी जब आपको शामिल करने की आवश्यकता होती है, और कभी-कभी आवश्यकता होती है, तो वे अधिकांश प्रोग्रामिंग भाषाओं में दो मौलिक रूप से अलग अवधारणाएं हैं, नोड जेएस भी। जगह में js को शामिल करने की क्षमता ईमानदार होने के लिए नोड का एक हिस्सा होना चाहिए, लेकिन इसे अनिवार्य रूप से एक सभ्य समाधान है। Upvoted।

— जे। मार्टिन

ध्यान दें कि उपयोग सख्त के साथ असंगत है - जैसा कि सख्त उपयोग से eval के माध्यम से नए चर का परिचय अवरुद्ध करके eval के उपयोग को बाधित होगा, आदि

— timo

Answer 3

आपको न तो नए कार्यों की आवश्यकता है और न ही नए मॉड्यूल की। यदि आप नाम स्थान का उपयोग नहीं करना चाहते हैं तो आपको बस उस मॉड्यूल को निष्पादित करना होगा जिसे आप कॉल कर रहे हैं।

टूल्स में। js

module.exports = function() { 
    this.sum = function(a,b) { return a+b };
    this.multiply = function(a,b) { return a*b };
    //etc
}

app.js में

या किसी अन्य .js में जैसे myController.js:

के बजाय

var tools = require('tools.js') जो हमें एक नाम स्थान और कॉल टूल का उपयोग करने के लिए मजबूर करता है tools.sum(1,2);

हम बस फोन कर सकते हैं

require('tools.js')();

और फिर

sum(1,2);

मेरे मामले में मेरे पास नियंत्रकों के साथ एक फ़ाइल है ctrls.js

module.exports = function() {
    this.Categories = require('categories.js');
}

और मैं Categoriesहर संदर्भ में सार्वजनिक वर्ग के रूप में उपयोग कर सकता हूंrequire('ctrls.js')()

Comments

यह अधिक + 1s कैसे नहीं करता है? यह एक वास्तविक समाधान है कि प्रश्न क्या पूछता है (यद्यपि 'आधिकारिक' एक नहीं)। यह eval () से डिबग करने के लिए भी एक लाख गुना आसान है क्योंकि नोड केवल अपरिभाषित के बजाय वास्तविक फ़ाइल की ओर इशारा करते हुए एक उपयोगी कॉल स्टैक दे सकता है।

— user3413723

ध्यान दें कि आप आयातित मॉड्यूल में "सख्त" मोड का उपयोग नहीं कर सकते हैं।

— डेविड

@ निक पनोव: शानदार! यह ध्यान देने योग्य होना चाहिए कि यह काम करता है क्योंकि thisएक फ़ंक्शन वैश्विक गुंजाइश है जब फ़ंक्शन को सीधे कहा जाता है (किसी भी तरह से बाध्य नहीं)।

— उडो जी

इसने मेरे जीवन को बदल दिया, कोई मज़ाक नहीं था - एक 1000+ लाइन की फाइल थी जिसे मैं नहीं तोड़ सकता क्योंकि विभिन्न तरीकों के चर सभी परस्पर-संबद्ध हैं और सभी को एक ही दायरे में होने की आवश्यकता होगी ... require('blah.js')();चाहिए मुझे उन सभी को एक ही दायरे में आयात करने की अनुमति दें !!! धन्यवाद!!!

— सैम जॉन्सन

यह एक महान टिप है! कैविएट: यदि आप मानक फ़ंक्शन () {} डिक्लेरेशन के बजाय () => {} शॉर्टकट सिंटैक्स का उपयोग करके मॉड्यूल.exports फ़ंक्शन की घोषणा करते हैं, तो यह विफल हो जाता है। मुझे यह जानने में एक घंटा लगा कि समस्या कहाँ है! (एरो फ़ंक्शंस के पास अपनी 'यह' संपत्ति नहीं है: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… )

— रयान ग्रिग्स

Answer 4

दो js फ़ाइलें बनाएँ

// File cal.js
module.exports = {
    sum: function(a,b) {
        return a+b
    },
    multiply: function(a,b) {
        return a*b
    }
};

मुख्य जेएस फ़ाइल

// File app.js
var tools = require("./cal.js");
var value = tools.sum(10,20);
console.log("Value: "+value);

कंसोल आउटपुट

Value: 30

Comments

किस संस्करण का js यह काम करता है?

— मीरव - मैट

Answer 5

यहाँ एक सादा और सरल विवरण दिया गया है:

Server.js सामग्री:

// Include the public functions from 'helpers.js'
var helpers = require('./helpers');

// Let's assume this is the data which comes from the database or somewhere else
var databaseName = 'Walter';
var databaseSurname = 'Heisenberg';

// Use the function from 'helpers.js' in the main file, which is server.js
var fullname = helpers.concatenateNames(databaseName, databaseSurname);

सहायक सामग्री:

// 'module.exports' is a node.JS specific feature, it does not work with regular JavaScript
module.exports = 
{
  // This is the function which will be called in the main file, which is server.js
  // The parameters 'name' and 'surname' will be provided inside the function
  // when the function is called in the main file.
  // Example: concatenameNames('John,'Doe');
  concatenateNames: function (name, surname) 
  {
     var wholeName = name + " " + surname;

     return wholeName;
  },

  sampleFunctionTwo: function () 
  {

  }
};

// Private variables and functions which will not be accessible outside this file
var privateFunction = function () 
{
};

Answer 6

मैं एक NodeJS 'फंक्शन' को भी शामिल करना चाह रहा था और मैंने उडो जी द्वारा प्रस्तावित समाधान की जाँच की - संदेश देखें https://stackoverflow.com/a/8744519/2979590 । उसका कोड मेरे शामिल JS फाइलों के साथ काम नहीं करता है। अंत में मैंने इस तरह की समस्या को हल किया:

var fs = require("fs");

function read(f) {
  return fs.readFileSync(f).toString();
}
function include(f) {
  eval.apply(global, [read(f)]);
}

include('somefile_with_some_declarations.js');

ज़रूर, इससे मदद मिलती है।

Comments

मुझे समझ में आया कि यह हैक कितना बदसूरत है, लेकिन इसने यकीनन मेरी मदद की।

— सिंह

Answer 7

दो फाइल बनाएं उदा app.jsऔरtools.js

app.js

const tools= require("./tools.js")


var x = tools.add(4,2) ;

var y = tools.subtract(4,2);


console.log(x);
console.log(y);

tools.js

 const add = function(x, y){
        return x+y;
    }
 const subtract = function(x, y){
            return x-y;
    }

    module.exports ={
        add,subtract
    }

उत्पादन

6
2

Answer 8

हम फ़ंक्शन पिंग को कॉल करना चाहते हैं () और जोड़ना (30,20), जो lib.js फ़ाइल में main.js से है ।

main.js

lib = require("./lib.js")

output = lib.ping();
console.log(output);

//Passing Parameters
console.log("Sum of A and B = " + lib.add(20,30))

lib.js

this.ping=function ()
{
    return  "Ping Success"
}

//Functions with parameters
this.add=function(a,b)
    {
        return a+b
    }

Comments

यह काम करता है, लेकिन स्क्रिप्ट सहित जब हम मॉड्यूल सिंटैक्स का उपयोग करने वाले नहीं हैं?

— कोकोडोको

Answer 9

Node.js में vm मॉड्यूल वर्तमान संदर्भ (वैश्विक ऑब्जेक्ट सहित) के भीतर जावास्क्रिप्ट कोड को निष्पादित करने की क्षमता प्रदान करता है। Http://nodejs.org/docs/latest/api/vm.html#vm_vm_runinthiscontext_code_filename देखें

ध्यान दें कि, आज के रूप में, vm मॉड्यूल में एक बग है जो एक नया संदर्भ से आह्वान करने पर सही चलने सेInInThisContext को पूर्ववर्ती करता है। यह केवल तभी मायने रखता है जब आपका मुख्य कार्यक्रम एक नए संदर्भ में कोड निष्पादित करता है और फिर वह कोड runInThisContext कहता है। Https://github.com/joyent/node/issues/898 देखें

अफसोस की बात है कि फर्नांडो ने सुझाव दिया है कि वैश्विक समारोह के साथ "फ़ंक्शन फू () {}" जैसे नामित कार्यों के लिए काम नहीं करेगा।

संक्षेप में, यहाँ एक कार्य () फ़ंक्शन है जो मेरे लिए काम करता है:

function include(path) {
    var code = fs.readFileSync(path, 'utf-8');
    vm.runInThisContext(code, path);
}

Comments

मुझे एक और SO उत्तर में vm.runInThisContext मिला, और "वेनिला" जावास्क्रिप्ट कोड फ़ाइलों को शामिल करने के लिए इसका उपयोग किया गया था। फिर भी मैंने इसे नोड कार्यक्षमता (जैसे "var fs = आवश्यकता ('fs')") पर निर्भर कोड को शामिल करने के लिए उपयोग करने की कोशिश की, और यह काम नहीं करेगा। उस मामले में, हालांकि, "eval" समाधान (ओं) के एक जोड़े के जवाब में, वास्तव में काम करता है।

— डेक्‍सीजन

इसे थोड़ा और अधिक सोचने के बाद, जब आपको नोड कार्यक्षमता पर निर्भर करने वाले कोड को शामिल करने की आवश्यकता शुरू होती है, तो संभवतः यह एक मॉड्यूल लिखने का समय है, हालांकि उस प्रक्रिया में eval solution पहला कदम हो सकता है

— Dexygen

केवल एक जो 2019 में नोड.जेएस में काम करता था

— meesern

Answer 10

उडो जी ने कहा:

• निष्कासन () का उपयोग किसी फ़ंक्शन के अंदर नहीं किया जा सकता है और इसे वैश्विक दायरे के अंदर बुलाया जाना चाहिए अन्यथा कोई फ़ंक्शन या चर सुलभ नहीं होंगे (यानी आप एक शामिल नहीं कर सकते हैं) उपयोगिता फ़ंक्शन या ऐसा कुछ)।

वह सही है, लेकिन एक फ़ंक्शन से वैश्विक गुंजाइश को प्रभावित करने का एक तरीका है। उनके उदाहरण में सुधार:

function include(file_) {
    with (global) {
        eval(fs.readFileSync(file_) + '');
    };
};

include('somefile_with_some_declarations.js');

// the declarations are now accessible here.

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

Answer 11

इसने मेरे साथ निम्नलिखित की तरह काम किया ...।

Lib1.js

//Any other private code here 

// Code you want to export
exports.function1 = function(params) {.......};
exports.function2 = function(params) {.......};

// Again any private code

अब Main.js फ़ाइल में आपको Lib1.js शामिल करने की आवश्यकता है

var mylib = requires('lib1.js');
mylib.function1(params);
mylib.function2(params);

कृपया याद रखें कि Lib1.js को node_modules फ़ोल्डर में रखें ।

Answer 12

आप अपने कार्यों को वैश्विक चर में रख सकते हैं, लेकिन अपने टूल स्क्रिप्ट को मॉड्यूल में बदलना बेहतर है। यह वास्तव में बहुत कठिन नहीं है - बस अपने सार्वजनिक एपीआई को exportsऑब्जेक्ट में संलग्न करें । पर एक नजर डालें समझौता Node.js 'निर्यात मॉड्यूल कुछ और अधिक विस्तार के लिए।

Comments

एक उदाहरण एक कड़ी से बेहतर है

— tno2007

Answer 13

मेरी राय में ऐसा करने का एक और तरीका है, जब आप आवश्यक कॉल करते हैं तो सब कुछ काम में आता है () (फ़ंक्शन (* यहां चीजें * /) {}) () फ़ंक्शन का उपयोग करके ; ऐसा करने से ये सभी कार्य वैश्विक दायरे में आ जाएंगे, बिल्कुल वैसा ही ( जैसे ) समाधान

src / lib.js

(function () {
    funcOne = function() {
            console.log('mlt funcOne here');
    }

    funcThree = function(firstName) {
            console.log(firstName, 'calls funcThree here');
    }

    name = "Mulatinho";
    myobject = {
            title: 'Node.JS is cool',
            funcFour: function() {
                    return console.log('internal funcFour() called here');
            }
    }
})();

और फिर अपने मुख्य कोड में आप अपने कार्यों को नाम से बुला सकते हैं जैसे:

main.js

require('./src/lib')
funcOne();
funcThree('Alex');
console.log(name);
console.log(myobject);
console.log(myobject.funcFour());

इसे आउटपुट करेंगे

bash-3.2$ node -v
v7.2.1
bash-3.2$ node main.js 
mlt funcOne here
Alex calls funcThree here
Mulatinho
{ title: 'Node.JS is cool', funcFour: [Function: funcFour] }
internal funcFour() called here
undefined

करने के लिए वेतन atention अपरिभाषित जब तुम मेरे फोन object.funcFour () , यदि आप के साथ लोड वही होगा eval () । आशा है ये मदद करेगा :)

Answer 14

मैं बस जोड़ना चाहता हूं, यदि आपको अपने टूल्स से आयातित कुछ कार्यों की आवश्यकता है। जेएस , तो आप एक विनाशकारी असाइनमेंट का उपयोग कर सकते हैं जो कि संस्करण 6.4 में नोड.जेएस में समर्थित है - नोड नोड देखें ।

---

उदाहरण : (दोनों फाइलें एक ही फ़ोल्डर में हैं)

tools.js

module.exports = {
    sum: function(a,b) {
        return a + b;
    },
    isEven: function(a) {
        return a % 2 == 0;
    }
};

main.js

const { isEven } = require('./tools.js');

console.log(isEven(10));

उत्पादन: true

---

इससे यह भी बचा जा सकता है कि आप उन कार्यों को किसी अन्य वस्तु के गुणों के रूप में असाइन करते हैं जैसा कि निम्नलिखित (सामान्य) असाइनमेंट में मामला है:

const tools = require('./tools.js');

जहां कॉल करने की आवश्यकता tools.isEven(10)।

---

ध्यान दें:

अपने फ़ाइल नाम को सही पथ के साथ उपसर्ग करना न भूलें - भले ही दोनों फ़ाइलें एक ही फ़ोल्डर में हों, आपको उपसर्ग करने की आवश्यकता है ./

से Node.js डॉक्स :

किसी फ़ाइल को इंगित करने के लिए एक अग्रणी '/', './', या '../' के बिना, मॉड्यूल को या तो एक कोर मॉड्यूल होना चाहिए या नोड_मॉडल फ़ोल्डर से लोड किया जाना चाहिए।

Answer 15

app.js

let { func_name } = require('path_to_tools.js');
func_name();    //function calling

tools.js

let func_name = function() {
    ...
    //function body
    ...
};

module.exports = { func_name };

Answer 16

फ़ाइल को शामिल करें और इसे दिए गए (गैर-वैश्विक) संदर्भ में चलाएं

fileToInclude.js

define({
    "data": "XYZ"
});

main.js

var fs = require("fs");
var vm = require("vm");

function include(path, context) {
    var code = fs.readFileSync(path, 'utf-8');
    vm.runInContext(code, vm.createContext(context));
}


// Include file

var customContext = {
    "define": function (data) {
        console.log(data);
    }
};
include('./fileToInclude.js', customContext);

Answer 17

यह मेरा अब तक का सबसे अच्छा तरीका है।

var fs = require('fs'),
    includedFiles_ = {};

global.include = function (fileName) {
  var sys = require('sys');
  sys.puts('Loading file: ' + fileName);
  var ev = require(fileName);
  for (var prop in ev) {
    global[prop] = ev[prop];
  }
  includedFiles_[fileName] = true;
};

global.includeOnce = function (fileName) {
  if (!includedFiles_[fileName]) {
    include(fileName);
  }
};

global.includeFolderOnce = function (folder) {
  var file, fileName,
      sys = require('sys'),
      files = fs.readdirSync(folder);

  var getFileName = function(str) {
        var splited = str.split('.');
        splited.pop();
        return splited.join('.');
      },
      getExtension = function(str) {
        var splited = str.split('.');
        return splited[splited.length - 1];
      };

  for (var i = 0; i < files.length; i++) {
    file = files[i];
    if (getExtension(file) === 'js') {
      fileName = getFileName(file);
      try {
        includeOnce(folder + '/' + file);
      } catch (err) {
        // if (ext.vars) {
        //   console.log(ext.vars.dump(err));
        // } else {
        sys.puts(err);
        // }
      }
    }
  }
};

includeFolderOnce('./extensions');
includeOnce('./bin/Lara.js');

var lara = new Lara();

आपको अभी भी सूचित करना होगा कि आप क्या निर्यात करना चाहते हैं

includeOnce('./bin/WebServer.js');

function Lara() {
  this.webServer = new WebServer();
  this.webServer.start();
}

Lara.prototype.webServer = null;

module.exports.Lara = Lara;

Answer 18

जैसे आप एक फ़ाइल abc.txtऔर कई और अधिक कर रहे हैं ?

2 फ़ाइलें बनाएँ: fileread.jsऔर fetchingfile.js, फिर fileread.jsइस कोड को लिखें:

function fileread(filename) {
    var contents= fs.readFileSync(filename);
        return contents;
    }

    var fs = require("fs");  // file system

    //var data = fileread("abc.txt");
    module.exports.fileread = fileread;
    //data.say();
    //console.log(data.toString());
}

में fetchingfile.jsलिखने के लिए इस कोड:

function myerror(){
    console.log("Hey need some help");
    console.log("type file=abc.txt");
}

var ags = require("minimist")(process.argv.slice(2), { string: "file" });
if(ags.help || !ags.file) {
    myerror();
    process.exit(1);
}
var hello = require("./fileread.js");
var data = hello.fileread(ags.file);  // importing module here 
console.log(data.toString());

अब, एक टर्मिनल में: $ नोड fetchingfile.js --file = abc.txt

आप फ़ाइल नाम को एक तर्क के रूप में पारित कर रहे हैं, इसके अलावा सभी फ़ाइलों readfile.jsको पारित करने के बजाय इसमें शामिल हैं।

धन्यवाद

Answer 19

आप बस सरल कर सकते हैं require('./filename')।

उदाहरण के लिए।

// file: index.js
var express = require('express');
var app = express();
var child = require('./child');
app.use('/child', child);
app.get('/', function (req, res) {
  res.send('parent');
});
app.listen(process.env.PORT, function () {
  console.log('Example app listening on port '+process.env.PORT+'!');
});

// file: child.js
var express = require('express'),
child = express.Router();
console.log('child');
child.get('/child', function(req, res){
  res.send('Child2');
});
child.get('/', function(req, res){
  res.send('Child');
});

module.exports = child;

कृपया ध्यान दें कि:

1. आप चाइल्ड फ़ाइल पर PORT नहीं सुन सकते, केवल पैरेंट एक्सप्रेस मॉड्यूल में PORT श्रोता हैं
2. चाइल्ड 'राउटर' का इस्तेमाल कर रहा है, न कि पैरेंट एक्सप्रेस के मौडल का।

Answer 20

मैं मॉड्यूल लिखने के बिना कोड को शामिल करने के विकल्प के रूप में अच्छी तरह से खोज रहा था, सम्मान। Node.js सेवा के लिए एक अलग परियोजना से एक ही परीक्षण किए गए स्टैंडअलोन स्रोतों का उपयोग करें - और jmparatte के उत्तर ने मेरे लिए ऐसा किया।

लाभ यह है, आप नाम स्थान को प्रदूषित नहीं करते, मुझे इससे कोई परेशानी नहीं है "use strict"; और यह अच्छी तरह से काम करता है।

यहाँ एक पूर्ण नमूना:

स्क्रिप्ट लोड करने के लिए - /lib/foo.js

"use strict";

(function(){

    var Foo = function(e){
        this.foo = e;
    }

    Foo.prototype.x = 1;

    return Foo;

}())

सैंपलमॉडल - index.js

"use strict";

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

var SampleModule = module.exports = {

    instAFoo: function(){
        var Foo = eval.apply(
            this, [fs.readFileSync(path.join(__dirname, '/lib/foo.js')).toString()]
        );
        var instance = new Foo('bar');
        console.log(instance.foo); // 'bar'
        console.log(instance.x); // '1'
    }

}

आशा है कि यह किसी भी तरह मददगार था।

Answer 21

नोड.जेएस और एक्सप्रेस.जेएस फ्रेमवर्क का उपयोग करते समय एक और विधि

var f1 = function(){
   console.log("f1");
}
var f2 = function(){
   console.log("f2");
}

module.exports = {
   f1 : f1,
   f2 : f2
}

इसे js फ़ाइल में s और फ़ोल्डर स्टेटिक्स में संग्रहीत करें

अब फ़ंक्शन का उपयोग करने के लिए

var s = require('../statics/s');
s.f1();
s.f2();

Answer 22

मैं HTML टेंपलेटिंग के लिए इसे संभालने के बजाय एक क्रूड विधि के साथ आया हूं। इसी तरह PHP के लिए<?php include("navigation.html"); ?>

server.js

var fs = require('fs');

String.prototype.filter = function(search,replace){
    var regex = new RegExp("{{" + search.toUpperCase() + "}}","ig");
    return this.replace(regex,replace);
}

var navigation = fs.readFileSync(__dirname + "/parts/navigation.html");

function preProcessPage(html){
    return html.filter("nav",navigation);
}

var express = require('express');
var app = express();
// Keep your server directory safe.
app.use(express.static(__dirname + '/public/'));
// Sorta a server-side .htaccess call I suppose.
app.get("/page_name/",function(req,res){
    var html = fs.readFileSync(__dirname + "/pages/page_name.html");
    res.send(preProcessPage(html));
});

page_name.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <title>NodeJS Templated Page</title>
    <link rel="stylesheet" type="text/css" href="/css/bootstrap.min.css">
    <link rel="stylesheet" type="text/css" href="/css/font-awesome.min.css">
    <!-- Scripts Load After Page -->
    <script type="text/javascript" src="/js/jquery.min.js"></script>
    <script type="text/javascript" src="/js/tether.min.js"></script>
    <script type="text/javascript" src="/js/bootstrap.min.js"></script>
</head>
<body>
    {{NAV}}
    <!-- Page Specific Content Below Here-->
</body>
</html>

navigation.html

<nav></nav>

लोड किया गया पृष्ठ परिणाम

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <title>NodeJS Templated Page</title>
    <link rel="stylesheet" type="text/css" href="/css/bootstrap.min.css">
    <link rel="stylesheet" type="text/css" href="/css/font-awesome.min.css">
    <!-- Scripts Load After Page -->
    <script type="text/javascript" src="/js/jquery.min.js"></script>
    <script type="text/javascript" src="/js/tether.min.js"></script>
    <script type="text/javascript" src="/js/bootstrap.min.js"></script>
</head>
<body>
    <nav></nav>
    <!-- Page Specific Content Below Here-->
</body>
</html>

Answer 23

यदि आप चीजों को गति देने के लिए कई सीपीयू और माइक्रोसर्विस आर्किटेक्चर का लाभ उठाना चाहते हैं ... तो कांटे की प्रक्रियाओं पर आरपीसी का उपयोग करें।

जटिल लगता है, लेकिन यह सरल है अगर आप ऑक्टोपस का उपयोग करते हैं ।

यहाँ एक उदाहरण है:

tools.js पर जोड़ें:

const octopus = require('octopus');
var rpc = new octopus('tools:tool1');

rpc.over(process, 'processRemote');

var sum = rpc.command('sum'); // This is the example tool.js function to make available in app.js

sum.provide(function (data) { // This is the function body
    return data.a + data.b;
});

app.js पर, जोड़ें:

const { fork } = require('child_process');
const octopus = require('octopus');
const toolprocess = fork('tools.js');

var rpc = new octopus('parent:parent1');
rpc.over(toolprocess, 'processRemote');

var sum = rpc.command('sum');

// Calling the tool.js sum function from app.js
sum.call('tools:*', {
    a:2, 
    b:3
})
.then((res)=>console.log('response : ',rpc.parseResponses(res)[0].response));

प्रकटीकरण - मैं ऑक्टोपस का लेखक हूं, और अगर मेरा कोई समान उपयोग नहीं होता है, तो मैं किसी भी हल्के पुस्तकालयों को नहीं पा सकता हूं।

Answer 24

मॉड्यूल में "टूल" को चालू करने के लिए, मुझे मुश्किल नहीं दिख रहा है। अन्य सभी उत्तरों के बावजूद मैं अभी भी मॉड्यूल.एक्सपोर्ट के उपयोग की सिफारिश करूंगा:

//util.js
module.exports = {
   myFunction: function () {
   // your logic in here
   let message = "I am message from myFunction";
   return message; 
  }
}

अब हमें इस निर्यात को वैश्विक दायरे में रखने की जरूरत है (आपके ऐप में | इंडेक्स | सर्वर.जेएस)

var util = require('./util');

अब आप फ़ंक्शन को संदर्भित कर सकते हैं और कॉल कर सकते हैं:

//util.myFunction();
console.log(util.myFunction()); // prints in console :I am message from myFunction 

Answer 25

उपयोग:

var mymodule = require("./tools.js")

app.js:

module.exports.<your function> = function () {
    <what should the function do>
}

Comments

आपको लगभग पूरी निर्देशिका का उपयोग कभी नहीं करना चाहिए। आपको सापेक्ष रास्तों का उपयोग करने पर विचार करना चाहिए जैसे:./tools.js

— मैथ्यू डी औल्ड