कैसे नोड बनाने के लिए। Js निरपेक्ष की आवश्यकता है? (रिश्तेदार के बजाय)

234

मैं अपनी फ़ाइलों को हमेशा अपनी परियोजना की जड़ से और वर्तमान मॉड्यूल के सापेक्ष नहीं चाहिए।

उदाहरण के लिए यदि आप https://github.com/visionmedia/express/blob/2820f2227de0229c5d7f28009aa432f9f3a7b5f9/examples-downloads/app.js लाइन 6 को देखेंगे तो आप देखेंगे।

express = require('../../')

यह वास्तव में बुरा है IMO। कल्पना कीजिए कि मैं अपने सभी उदाहरणों को केवल एक स्तर तक जड़ के करीब रखना चाहूंगा। यह असंभव होगा, क्योंकि मुझे प्रत्येक उदाहरण में 30 से अधिक उदाहरण और कई बार अपडेट करने होंगे। इसके लिए:

express = require('../')

मेरा समाधान रूट आधारित के लिए एक विशेष मामला होगा: यदि एक स्ट्रिंग $ से शुरू होती है, तो यह परियोजना के रूट फ़ोल्डर के सापेक्ष है।

हर प्रकार की सहायता का स्वागत है, धन्यवाद

अपडेट २

अब मैं आवश्यकता का उपयोग कर रहा हूं। जेएस जो आपको एक तरह से लिखने की अनुमति देता है और क्लाइंट और सर्वर दोनों पर काम करता है। आवश्यकता.जेएस आपको कस्टम पथ बनाने की अनुमति भी देता है।

अपडेट ३

अब मैं webpack + gulp में चला गया और मैं सर्वर साइड पर मॉड्यूल को संभालने के लिए एन्हांस्ड-आवश्यकता का उपयोग करता हूं। यहां देखें तर्क: http://hackhat.com/p/110/module-loader-webpack-vs-requirejs-vs-browserify/

node.js  require 
— Totty.js
स्रोत
यदि आप कभी भी एक स्पष्ट रूट पथ स्थिर / चर का उपयोग करने का निर्णय लेते हैं, तो यह उत्तर उसी के लिए काम करता है । रूट पथ को निर्धारित करने के लिए समाधान एक छोटे गितुब मॉड्यूल का उपयोग करता है।
— भाप से चलने वाला
— zloctb

जवाबों:

162

और क्या इस बारे में:

var myModule = require.main.require('./path/to/module');

इसमें फ़ाइल की आवश्यकता होती है जैसे कि यह मुख्य js फ़ाइल से आवश्यक थी, इसलिए यह तब तक अच्छी तरह से काम करती है जब तक कि आपकी मुख्य js फ़ाइल आपके प्रोजेक्ट के मूल में है ... और यह ऐसी चीज है जिसकी मैं सराहना करता हूं।

— cronvel
स्रोत
एक बुरा विचार नहीं है: (आप तब किसी अन्य तरीके को परिभाषित कर सकते हैं ताकि किसी ऐप को अपने आवश्यकता-पूर्ति मॉड्यूल में फिर से डाल दिया जा सके। मुझे लगता है कि आप तब आवश्यकता कर सकते हैं। pm.req ('ग्राहक / someMod')। अच्छा विचार है, लेकिन यह विचार है। मेरी वर्तमान आवश्यकताओं की तुलना में अधिक क्रियात्मक हो। इसके अलावा मुझे नहीं लगता कि मैं इसके लायक है क्योंकि मैं भी ब्राउज़र को नापसंद करता हूं क्योंकि परिवर्तन तत्काल नहीं हैं और परिवर्तन याद करते हैं (क्योंकि मेरा कोड ब्राउज़र और नोड दोनों में ही चलना चाहिए)।
— Totty.js
4
यदि आप इसे बहुत अधिक वर्बोज़ पाते हैं, तो बस .bind (): var rootReq = requirement.bind (requ.main) का उपयोग करें; rootReq ('./path/to/module');
— क्रोनवेल
हां, यह किसी के लिए उपयोगी हो सकता है जो अभी भी क्लाइंट साइड के लिए ब्राउजर का उपयोग करना चाहता है। मेरे लिए अब और कोई आवश्यकता नहीं है, लेकिन आपके उत्तर के लिए वैसे भी धन्यवाद: (:
— Totty.js
6
अगर आपके प्रॉजेक्ट के आधार पर मुख्य है :)
— अलेक्जेंडर मिल्स
12
यह समाधान काम नहीं करेगा यदि कोड को मोचा टेस्ट जैसे यूनिट टेस्ट से कवर किया गया हो
— alx lark
129

ब्राउज़र हैंडबुक में वास्तव में एक दिलचस्प खंड है :

परहेज ../../../../../../ ।।

ठीक से एक आवेदन में सब कुछ सार्वजनिक npm पर नहीं है और एक निजी npm या git रेपो स्थापित करने का ओवरहेड अभी भी कई मामलों में बड़ा है। ../../../../../../../रिश्तेदार पथ की समस्या से बचने के लिए यहां कुछ दृष्टिकोण दिए गए हैं ।

node_modules

कभी-कभी लोग एप्लिकेशन-विशिष्ट मॉड्यूल को नोड_मॉड्यूल्स में डालने पर आपत्ति करते हैं क्योंकि यह स्पष्ट नहीं है कि आपके आंतरिक मॉड्यूल को कैसे चेक करना है, वह भी npm से तीसरे पक्ष के मॉड्यूल में जांच किए बिना।

जवाब बहुत सरल है! यदि आपके पास कोई .gitignoreफ़ाइल है जो अनदेखा करती है node_modules:

node_modules

आप !अपने प्रत्येक आंतरिक एप्लिकेशन मॉड्यूल के साथ केवल एक अपवाद जोड़ सकते हैं :

node_modules/*
!node_modules/foo
!node_modules/bar

कृपया ध्यान दें कि यदि आप पहले से ही नजरअंदाज कर दिए गए हैं, तो आप एक उपनिर्देशिका को नहीं सौंप सकते । इसलिए अनदेखा करने के बजाय node_modules, आपको प्रत्येक निर्देशिका को अंदर से अनदेखा करना node_modulesहोगा node_modules/* चाल, और फिर आप अपने अपवाद जोड़ सकते हैं।

अब आपके आवेदन में कहीं भी आप require('foo') या कर सकेंगेrequire('bar') एक बहुत बड़े और नाजुक रिश्तेदार पथ के बिना ।

यदि आपके पास बहुत सारे मॉड्यूल हैं और उन्हें npm द्वारा स्थापित तीसरे पक्ष के मॉड्यूल से अधिक अलग रखना चाहते हैं, तो आप बस उन सभी को एक निर्देशिका के तहत रख सकते हैं node_modulesजैसे node_modules/app:

node_modules/app/foo
node_modules/app/bar

अब आप कर पाएंगे require('app/foo')या नहींrequire('app/bar') अपने आवेदन में कहीं से भी कहीं से भी ।

आपके लिए .gitignore, बस इसके लिए एक अपवाद जोड़ें node_modules/app:

node_modules/*
!node_modules/app

यदि आपके एप्लिकेशन ने पैकेज.जॉसन में कॉन्फ़िगर किए गए ट्रांसफ़ॉर्म किए थे, तो आपको अपने node_modules/fooया अपने स्वयं के ट्रांसफ़ॉर्म फ़ील्ड के साथ एक अलग पैकेज बनाने की आवश्यकता होगी।node_modules/app/foo घटक निर्देशिका क्योंकि ट्रांसफ़ॉर्म मॉड्यूल सीमाओं पर लागू नहीं होते हैं। इससे आपके एप्लिकेशन में कॉन्फ़िगरेशन परिवर्तन के खिलाफ आपके मॉड्यूल और अधिक मजबूत हो जाएंगे और आपके एप्लिकेशन के बाहर के पैकेज का स्वतंत्र रूप से पुन: उपयोग करना आसान हो जाएगा।

सिमलिंक

एक और आसान ट्रिक यदि आप किसी ऐसे एप्लिकेशन पर काम कर रहे हैं, जहां आप सिम्बलिंक बना सकते हैं और विंडोज़ का समर्थन करने की आवश्यकता नहीं है, तो किसी फ़ोल्डर lib/ या app/फ़ोल्डर को सिमलिंक करना है node_modules। प्रोजेक्ट रूट से, करें:

ln -s ../lib node_modules/app

और अब अपनी परियोजना में कहीं से भी आप में फ़ाइलों की आवश्यकता कर सकेंगे lib/करके require('app/foo.js')प्राप्त करने के लिए lib/foo.js।

कस्टम पथ

आप कुछ स्थानों को $NODE_PATH पर्यावरण चर का उपयोग करने के बारे में बात करते हुए देख सकते हैं या opts.pathsनोड के लिए निर्देशिका जोड़ सकते हैं और मॉड्यूल खोजने के लिए ब्राउज़र कर सकते हैं।

अधिकांश अन्य प्लेटफार्मों के विपरीत, पथ निर्देशिकाओं के शेल-शैली सरणी का $NODE_PATHउपयोग करके node_modulesनिर्देशिका का प्रभावी उपयोग करने की तुलना में नोड के रूप में अनुकूल नहीं है ।

ऐसा इसलिए है क्योंकि आपके एप्लिकेशन को रनटाइम पर्यावरण कॉन्फ़िगरेशन के लिए अधिक कसकर युग्मित किया गया है ताकि अधिक चलते हुए हिस्से हों और आपका एप्लिकेशन तभी काम करेगा जब आपका वातावरण सही तरीके से सेटअप हो।

नोड और ब्राउज़र समर्थन दोनों लेकिन के उपयोग को हतोत्साहित करते हैं $NODE_PATH।

— पाओलो मोरेटी
स्रोत
17
इसे node_modulesफ़ोल्डर में रखने का एकमात्र नीचे का पक्ष यह है कि यह nuke ( rm -rf node_modules) फ़ोल्डर के लिए कठिन बनाता है
— Michael
13
@ मिचेल इतना कठिन नहीं है: स्वच्छ क्लीन-डीएक्स नोड_मॉड्यूल्स
— पीटर विल्किंसन
3
या यदि आप git cleanवाक्यविन्यास को भूल गए हैं , तो कोई भी व्यक्ति हमेशा rm -rf node_modules && git checkout node_modulesसुनिश्चित हो सकता है - git stashयदि node_modulesउपनिर्देशिका में कोई बदलाव हो तो सुनिश्चित करें ।
— डेरेनियो
1
मुझे नोड_मॉडल का उपयोग करने का विचार पसंद है, लेकिन स्रोत कोड को संग्रहीत करने के लिए नहीं कि यह कितना अस्थिर हो सकता है। क्या यह अलग मॉड्यूल को प्रकाशित करने और मूल परियोजना में एक निर्भरता के रूप में सहेजने के लिए अधिक समझ में नहीं आएगा? यह नोड_मॉड्यूल्स निर्देशिका की अस्थिरता का एक स्पष्ट समाधान प्रदान करता है और केवल npm पर निर्भर करता है, बजाय git, प्रतीकात्मक लिंक या $ NODE_PATH समाधान पर भरोसा करने के।
— केविन कोशोल
1
NODE_PATH जाने का रास्ता दिखता है। "आपका एप्लिकेशन तभी काम करेगा जब आपका वातावरण सही ढंग से सेटअप हो" यह हमेशा सच है! क्या हर फ़ाइल में हर आयात को बदलने की तुलना में पर्यावरण सेटअप (आमतौर पर एक फ़ाइल में) प्राप्त करना आसान नहीं है?
— CpILL
73

मुझे node_modulesसाझा कोड के लिए एक नया फ़ोल्डर बनाना पसंद है , फिर नोड दें और इसे सबसे अच्छा करने की आवश्यकता है।

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

- node_modules // => these are loaded from your package.json
- app
  - node_modules // => add node-style modules
    - helper.js
  - models
    - user
    - car
- package.json
- .gitignore

उदाहरण के लिए, यदि आप car/index.jsकर सकते हैं require('helper')और नोड इसे मिल जाएगा!

कैसे नोड_मॉड्यूल काम करते हैं

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

यदि आप require('./foo.js')से /beep/boop/bar.js, नोड के लिए ./foo.jsमें दिखेगा /beep/boop/foo.js। पथ जो एक के साथ शुरू होते हैं ./या ../हमेशा उस फ़ाइल पर स्थानीय होते हैं जो कॉल करती है require()।

यदि फिर भी आप इस तरह के रूप में एक गैर-रिश्तेदार नाम की आवश्यकता require('xyz')से /beep/boop/foo.js, नोड खोजें क्रम में इन रास्तों, पहले मैच में रोकने और अगर कुछ भी नहीं पाया जाता है एक त्रुटि को ऊपर उठाने:

/beep/boop/node_modules/xyz
/beep/node_modules/xyz
/node_modules/xyz

xyzमौजूद प्रत्येक निर्देशिका के लिए , नोड पहले xyz/package.jsonयह देखेगा कि कोई "main"फ़ील्ड मौजूद है या नहीं। "main"क्षेत्र परिभाषित करता है जो फ़ाइल प्रभार लेने चाहिए अगर आपrequire() निर्देशिका पथ।

उदाहरण के लिए, यदि /beep/node_modules/xyzपहला मैच है और /beep/node_modules/xyz/package.jsonहै:

{
  "name": "xyz",
  "version": "1.2.3",
  "main": "lib/abc.js"
}

तब से निर्यात /beep/node_modules/xyz/lib/abc.jsद्वारा वापस कर दिया जाएगा require('xyz')।

यदि package.jsonकोई "main"क्षेत्र नहीं है या नहीं है , index.jsतो माना जाता है:

/beep/node_modules/xyz/index.js
— ब्लेयर एंडरसन
स्रोत
2
मॉड्यूल लोड करते समय यह कैसे काम करता है, इस पर महान विवरण
— goenning
2
यह एक बहुत ही सुंदर समाधान है, ऊपर दिए गए उत्तरों में सभी समस्याओं से बचा जाता है। उत्तर पर विचार करना चाहिए, इम्हो।
— रॉडरिको
38

बड़ी तस्वीर

यह "वास्तव में बुरा" लगता है लेकिन इसे समय दें। यह वास्तव में, वास्तव में अच्छा है। स्पष्ट require()एस एक परियोजना जीवन चक्र के दौरान ताजी हवा की सांस की तरह है कि कुल पारदर्शिता और समझने में आसानी देता है।

इसे इस तरह से सोचें: आप एक उदाहरण पढ़ रहे हैं, अपने पैर की उंगलियों को Node.js में डुबो रहे हैं और आपने निर्णय लिया है कि "वास्तव में खराब IMO है।" आप Node.js समुदाय के दूसरे-अनुमानित नेता हैं, जो लोग अधिक घंटे लिखने और किसी के साथ Node.js अनुप्रयोगों को बनाए रखने में लॉग इन हैं। क्या मौका है कि लेखक ने ऐसी धोखेबाज़ गलती की है? (और मैं सहमत हूं, मेरी रूबी और पायथन पृष्ठभूमि से, यह पहली बार एक आपदा की तरह लगता है।)

Node.js. के आसपास बहुत से प्रचार और प्रति-प्रचार हैं लेकिन जब धूल जम जाती है, तो हम स्वीकार करेंगे कि स्पष्ट मॉड्यूल और "स्थानीय पहले" पैकेज अपनाने के एक प्रमुख चालक थे।

आम मामला है

बेशक, node_modules वर्तमान निर्देशिका से, फिर माता-पिता, फिर दादा-दादी, परदादा, आदि की खोज की जाती है। तो आपके द्वारा पहले से स्थापित पैकेज इस तरह से काम करते हैं। आमतौर पर आप require("express")अपने प्रोजेक्ट में कहीं से भी आ सकते हैं और यह ठीक काम करता है।

यदि आप अपने प्रोजेक्ट की जड़ से खुद को आम फ़ाइलों को लोड करते हुए पाते हैं (शायद इसलिए कि वे सामान्य उपयोगिता वाले कार्य हैं), तो यह एक बड़ा सुराग है कि यह एक पैकेज बनाने का समय है। पैकेज बहुत सरल हैं: अपनी फ़ाइलों को स्थानांतरित करें node_modules/और एक डालेंpackage.json वहां । देखा! उस नामस्थान में सब कुछ आपकी पूरी परियोजना से सुलभ है। संकुल आपके कोड को वैश्विक नामस्थान में लाने का सही तरीका है।

अन्य workarounds के

मैं व्यक्तिगत रूप से इन तकनीकों का उपयोग नहीं करता, लेकिन वे आपके प्रश्न का उत्तर देते हैं, और निश्चित रूप से आप अपनी स्थिति को I से बेहतर जानते हैं।

आप $NODE_PATHअपने प्रोजेक्ट रूट पर सेट कर सकते हैं । जब आप उस निर्देशिका को खोज लेंगे require()।

इसके बाद, आप अपने सभी उदाहरणों से एक आम, स्थानीय फ़ाइल के लिए समझौता कर सकते हैं। वह सामान्य फ़ाइल बस दादा-दादी निर्देशिका में असली फ़ाइल को फिर से निर्यात करती है।

उदाहरण / डाउनलोड / app.js (और कई अन्य इसे पसंद करते हैं)

var express = require('./express')

उदाहरण / डाउनलोड / express.js

module.exports = require('../../')

अब जब आप उन फ़ाइलों को स्थानांतरित करते हैं, तो सबसे खराब स्थिति एक शिम मॉड्यूल को ठीक कर रही है ।

— JasonSmith
स्रोत
14
मैं मानता हूं कि Node.js लोगों ने एक कारण के लिए रिश्तेदार की आवश्यकता को चुना होगा। मैं न तो इसके फायदे देख सकता हूं, न ही आपके जवाब से। यह अभी भी मुझे "बुरा" लगता है;)
— एडम शमिदग
21
"आप Node.js समुदाय के दूसरे-अनुमानित नेता हैं" - समान नेताओं ने वायदा / वादों के बजाय कॉलबैक का उपयोग करने का निर्णय लिया। मेरे नोडज की सलाह के अधिकांश में "नेताओं" को कोसना शामिल है, और लोगों को जेवीएम में स्थानांतरित करने के लिए आश्वस्त करना शामिल है। नोडज का उपयोग करने के कुछ महीनों के बाद जो बहुत आसान है :)
— डेविड सर्गेई
8
@ निश्चय, झाविमो में कदम? भगवान के लिए, क्यों?
— इवानो
31
"आप Node.js समुदाय के दूसरे-अनुमानी नेता हैं" कृपया इस विचार-हतोत्साहित स्वर से बचें।
— atlex2
15
अरे ठीक है, वह दूसरा अनुमान लगाने वाले नोड नेता हैं। उद्योग कैसे आगे बढ़ता है। यदि नोड लोगों ने उन नेताओं का अनुमान नहीं लगाया था जो थ्रेड आधारित संगामिति मॉडल का प्रचार करते हैं, तो हमारे पास नोड नहीं होगा।
— d512
20

नोड- rfr पर एक नजर ।

यह इस तरह सरल है:

var rfr = require('rfr');
var myModule = rfr('projectSubDir/myModule');
— warmsea
स्रोत
मुझे लगता है कि दूसरी पंक्ति var myModule = rfr ('/ projectSubDir / myModule') होनी चाहिए;
— सिकोरस्की
1
डॉक्स से: var mod2 = rfr ('lib / मॉड्यूल2'); // अग्रणी स्लैश को छोड़ा जा सकता है।
— इगेलिन्यू
मैंने कोशिश की और यह rfr नोड के साथ निष्पादित करने के लिए ठीक काम करता है, लेकिन यह वी.एस. कोड के साथ कोड नेविगेशन को तोड़ता है ... मुझे
— वीआर
13

यदि आप npm के बजाय यार्न का उपयोग कर रहे हैं तो आप वर्कस्पेस का उपयोग कर सकते हैं ।

मान लीजिए कि मेरे पास एक फ़ोल्डर है जिसे servicesमैं और अधिक आसानी से प्राप्त करना चाहता हूं:

.
├── app.js
├── node_modules
├── test
├── services
│   ├── foo
│   └── bar
└── package.json

यार्न कार्यक्षेत्र बनाने के लिए, package.jsonअंदर एक फ़ाइल बनाएं services folder:

{
  "name": "myservices",
  "version": "1.0.0"
}

अपने मुख्य पैकेज में। json add:

"private": true,
"workspaces": ["myservices"]

yarn installप्रोजेक्ट के रूट से चलाएँ ।

फिर, आपके कोड में कहीं भी, आप कर सकते हैं:

const { myFunc } = require('myservices/foo')

बजाय कुछ की तरह:

const { myFunc } = require('../../../../../../services/foo')
— cyberwombat
स्रोत
6
शायद यह स्पष्ट करने का विचार है कि यह केवल यार्न के लिए काम करता है , एनपीएम के लिए नहीं? मुझे लगता है कि यह शायद npm के लिए भी काम करेगा, इसलिए थोड़ा समय बिताया जब तक मैंने यार्न का उपयोग करने की कोशिश नहीं की, तब तक मैंने क्या किया। एक मूर्खतापूर्ण धारणा हो सकती है, लेकिन शायद मैं अकेला नहीं हूं।
— ArneHugo
2
मैंने स्पष्ट करने के लिए थोड़ा संपादन किया है। गलतफहमी के लिए खेद है।
— सायबरवॉम्बैट
12

IMHO, सबसे आसान तरीका GLOBALऑब्जेक्ट के हिस्से के रूप में अपने स्वयं के फ़ंक्शन को परिभाषित करना है । projRequire.jsनिम्नलिखित सामग्री के साथ प्रोजेक्ट की जड़ में बनाएँ :

var projectDir = __dirname;

module.exports = GLOBAL.projRequire = function(module) {
  return require(projectDir + module);
}

requireकिसी भी परियोजना-विशिष्ट मॉड्यूल के अंतर्ग्रहण से पहले आपकी मुख्य फ़ाइल में :

// init projRequire
require('./projRequire');

उसके बाद मेरे लिए निम्नलिखित काम करता है:

// main file
projRequire('/lib/lol');

// index.js at projectDir/lib/lol/index.js
console.log('Ok');

@ बहुत, मैंने एक और समाधान के साथ काम किया है, जो आपके द्वारा टिप्पणियों में वर्णित मामले के लिए काम कर सकता है। विवरण होने वाला है tl;dr, इसलिए मैं अपने परीक्षण प्रोजेक्ट की संरचना के साथ बेहतर चित्र दिखाता हूं ।

— अलेक्सी ज़ाब्रोद्स्की
स्रोत
खैर, अब तक यह ऐसा करने का सबसे अच्छा तरीका लगता है। मैं करता हूं: GLOBAL.requires = आवश्यकता ('r') r; मेरी index.js फ़ाइल में। लेकिन मुझे अपने प्रतिज्ञा परीक्षणों में समस्या है, वे अनुक्रमणिका नहीं चलाते हैं। इसलिए मेरे परीक्षण विफल हो जाते हैं क्योंकि आवश्यकताएं अपरिभाषित हैं। वैसे भी अब मैं GLOBAL.requires = आवश्यकता ('r') जोड़ सकता हूँ। r; हर परीक्षा में सबसे ऊपर। कोई बेहतर विचार? github.com/totty90/production01_server/commit/…
— Totty.js
गैर परीक्षण फ़ाइलों के लिए: github.com/totty90/production01_server/blob/global-require/… , प्रत्येक परीक्षण फ़ाइल में: github.com/totty90/production01_server-blob/global-require/test/…
— Totty.js
समस्या तब होती है जब मैं "pathes-test / node_modules / other.js" में होता हूं और मुझे "pathes-test / node_modules / some.js" की आवश्यकता होती है। मुझे आवश्यकता ("प्रेज / कुछ") के बजाय ('./ कुछ') की आवश्यकता होगी। और इस तरह से मेरा सारा ऐप नोड_मॉड्यूल डीआईआर में होगा?
— टोट्टी.जेएस
@Totty, की आवश्यकता होती है कोई समस्या नहीं prj/someसे prj/other(बस का परीक्षण किया require('prj/some')। आप सभी ऐप के सामान्य मॉड्यूल वहां जा सकते हैं (जैसे डेटाबेस लेयर)। इससे कोई फ़र्क नहीं पड़ेगा कि आपका, चलो कहते हैं, libहै। कोशिश करो और देखो कि क्या यह सूट है।
— अलेक्सी ज़ाब्रोद्स्की 21
yest, मैंने इसे अपडेट किया है: github.com/totty90/production01_server/tree/master/node_modules/… जिसने बहुत अच्छा काम किया। लेकिन मैं अपने सभी फाइलों को नोड_मॉड्यूल्स का उपयोग किए बिना एक स्तर ऊपर रख सकता हूं?
— टोटी.जस
12

मैं process.cwd()अपने प्रोजेक्ट्स में इस्तेमाल करता हूं। उदाहरण के लिए:

var Foo = require(process.cwd() + '/common/foo.js');

यह ध्यान देने योग्य हो सकता है कि इसके परिणामस्वरूप requireएक निरपेक्ष पथ हो जाएगा, हालांकि मुझे अभी भी इसके साथ मुद्दों पर चलना है।

— वाल्टर रोमन
स्रोत
1
यह बुरा विचार है क्योंकि सीडब्ल्यूडी के पास वही निर्देशिका नहीं है जहां आवेदन सहेजा गया है।
— jiwopene
11

इस मुद्दे की यहाँ अच्छी चर्चा है ।

मैं एक ही वास्तुशिल्प समस्या में भाग गया: अपने आवेदन को अधिक संगठन और आंतरिक नामस्थान देने का एक तरीका चाहता हूं, बिना:

  • बाहरी निर्भरता के साथ अनुप्रयोग मॉड्यूल को मिलाकर या अनुप्रयोग-विशिष्ट कोड के लिए निजी npm रेपो के साथ परेशान
  • रिश्तेदार का उपयोग करने की आवश्यकता होती है, जो कि रिफैक्टिंग और समझ को कठिन बनाते हैं
  • सीलिंक का उपयोग करना या नोड पथ को बदलना, जो स्रोत स्थानों को अस्पष्ट कर सकते हैं और स्रोत नियंत्रण के साथ अच्छी तरह से नहीं खेल सकते हैं

अंत में, मैंने निर्देशिकाओं के बजाय फ़ाइल नामकरण सम्मेलनों का उपयोग करके अपने कोड को व्यवस्थित करने का निर्णय लिया। एक संरचना कुछ इस तरह दिखाई देगी:

  • NPM-shrinkwrap.json
  • package.json
  • node_modules
    • ...
  • src
    • app.js
    • app.config.js
    • app.models.bar.js
    • app.models.foo.js
    • app.web.js
    • app.web.routes.js
    • ...

फिर कोड में:

var app_config = require('./app.config');
var app_models_foo = require('./app.models.foo');

या केवल

var config = require('./app.config');
var foo = require('./app.models.foo');

और बाहरी निर्भरताएं हमेशा की तरह नोड_मॉडल से उपलब्ध हैं:

var express = require('express');

इस तरह, सभी एप्लिकेशन कोड पदानुक्रम में मॉड्यूल में व्यवस्थित होते हैं और एप्लिकेशन रूट के सापेक्ष अन्य सभी कोड के लिए उपलब्ध होते हैं।

मुख्य नुकसान यह है कि एक फ़ाइल ब्राउज़र में, आप पेड़ का विस्तार / पतन नहीं कर सकते हैं क्योंकि यह वास्तव में निर्देशिकाओं में व्यवस्थित था। लेकिन मुझे पसंद है कि यह बहुत स्पष्ट है कि सभी कोड कहां से आ रहे हैं, और यह किसी भी 'जादू' का उपयोग नहीं करता है।

— indirectlylit
स्रोत
आपके द्वारा लिंक किए गए जिस्ट से, समाधान # 7, "द रैपर", काफी सरल और सुविधाजनक है।
— पियर-ल्यूक गेंड्रेउ
मुझे एक और कम सुविधा दिखाई देती है - "फाइल को अलग-अलग" फ़ोल्डर में "स्थानांतरित करना" का नाम बदल जाता है - जो चलती फाइल की तुलना में अधिक आसान है। इसके अलावा, मुझे लगता है कि परियोजना पर काम के आधे घंटे के बाद, मेरे लगभग सभी ऐप ट्री का विस्तार वैसे भी किया जाता है। 1 स्तर के फोल्डर स्पेस को जोड़ने से बड़े कोडबेस को मैनेज किया जा सकता है और बहुत ज्यादा इंट्रोड्यूस नहीं किया जा सकता है, ../x/xजो पहले से ही पठनीय है।
— स्की
आप नोड्ज में स्पष्ट कमी को दूर करने के लिए, स्लैश के बजाय डॉट्स का उपयोग करके फ़ोल्डरों को फिर से कर रहे हैं।
— सिमोन गियानी
9

अपनी परियोजना की जड़ को वर्तमान कार्यशील निर्देशिका मानते हुए, यह काम करना चाहिए:

// require built-in path module
path = require('path');

// require file relative to current working directory
config = require( path.resolve('.','config.js') );
— protometa
स्रोत
config = require('./config.js');वैध है।
— सेस्पन
7
@cespon no, जो फाइल की आवश्यकता के सापेक्ष है।
— प्रोटोमेटा
8

मैंने इनमें से कई उपाय आजमाए हैं। मैंने इसे अपनी मुख्य फ़ाइल (जैसे index.js) के शीर्ष पर जोड़ दिया:

process.env.NODE_PATH = __dirname;
require('module').Module._initPaths();

यह स्क्रिप्ट लोड होने पर NODE_PATH को प्रोजेक्ट रूट जोड़ता है। मुझे अपनी परियोजना में किसी भी फाइल की आवश्यकता होती है, जैसे कि प्रोजेक्ट रूट से उसके सापेक्ष पथ को संदर्भित करके var User = require('models/user')। यह समाधान तब तक काम करना चाहिए जब तक आप अपने प्रोजेक्ट में कुछ और चलाने से पहले प्रोजेक्ट रूट में एक मुख्य स्क्रिप्ट चला रहे हों।

— senornestor
स्रोत
8

कुछ उत्तर कह रहे हैं कि सबसे अच्छा तरीका कोड को एक पैकेज के रूप में नोड_मॉड्यूल में जोड़ना है, मैं सहमत हूं और इसकी ../../../आवश्यकता को खोने का सबसे अच्छा तरीका है, लेकिन उनमें से कोई भी वास्तव में ऐसा करने का तरीका नहीं देता है।

संस्करण से 2.0.0आप स्थानीय फ़ाइलों से एक पैकेज स्थापित कर सकते हैं, जिसका अर्थ है कि आप अपने रूट में अपने इच्छित सभी पैकेजों के साथ फ़ोल्डर बना सकते हैं,

-modules
 --foo
 --bar 
-app.js
-package.json

इसलिए package.json में आप जोड़ सकते हैं modules(या fooऔर barप्रकाशित करने या इस तरह बाहरी सर्वर का उपयोग किए बिना) एक पैकेज के रूप में:

{
  "name": "baz",
  "dependencies": {
    "bar": "file: ./modules/bar",
    "foo": "file: ./modules/foo"
  }
}

उसके बाद आप करते हैं npm install, और आप के साथ कोड का उपयोग कर सकते हैं var foo = require("foo"), जैसे आप अन्य सभी पैकेजों के साथ करते हैं।

और अधिक जानकारी यहां पाई जा सकती है :

https://docs.npmjs.com/files/package.json#local-paths

और यहां पैकेज बनाने का तरीका:

https://docs.npmjs.com/getting-started/creating-node-modules

— यान मायात्स्की
स्रोत
1
"यह सुविधा स्थानीय ऑफ़लाइन विकास और परीक्षण बनाने के लिए सहायक है, जिसमें एनपीएम इंस्टॉल करने की आवश्यकता होती है, जहां आप बाहरी सर्वर को हिट नहीं करना चाहते हैं, लेकिन सार्वजनिक रजिस्ट्री में पैकेज प्रकाशित करते समय इसका उपयोग नहीं किया जाना चाहिए।"
— रेयान स्मिथ
7

आप मेरे द्वारा बनाये गए एक मॉड्यूल का उपयोग कर सकते हैं, Undot । यह कुछ भी उन्नत नहीं है, सिर्फ एक सहायक है ताकि आप सादगी से उन डॉट नरक से बच सकें।

उदाहरण:

var undot = require('undot');
var User = undot('models/user');
var config = undot('config');
var test = undot('test/api/user/auth');
— रेंड़ी
स्रोत
6

आप अपने app.js में कुछ इस तरह परिभाषित कर सकते हैं:

requireFromRoot = (function(root) {
    return function(resource) {
        return require(root+"/"+resource);
    }
})(__dirname);

और फिर कभी भी आप रूट से किसी चीज़ की आवश्यकता चाहते हैं, चाहे आप कहीं भी हों, आप केवल वेनिला आवश्यकता के बजाय फ़ार्मफ्रूट का उपयोग करें। मेरे लिए अब तक बहुत अच्छा काम करता है।

— user1417684
स्रोत
धन्यवाद! मुझे लगता है कि यह बहुत स्मार्ट और सीधा है।
— रयान
मुझे माफ कर दीजिये पिता जी मैं ने पाप किया है। मैंने इसे ES6 में पोर्ट किया और निम्नलिखित मिला requireFromRoot = ((root) => (resource) => require(`${root}/${resource}`))(__dirname);:। समाधान से प्यार है, लेकिन क्या आपको वास्तव में __dirname को उस तरह से बांधना है?
— नैक
1
इस पर मेरी मेमोरी थोड़ी धुंधली है, लेकिन मेरा मानना ​​है कि __dirname परिवर्तन मान पर निर्भर करता है कि यह किस फ़ाइल में उपयोग किया गया है। अब यह हो सकता है कि चूंकि फ़ंक्शन को एक ही स्थान पर परिभाषित किया गया है, लेकिन कई स्थानों पर उपयोग किया जाता है, इस बंधन के बिना भी मूल्य स्थिर रहेगा, लेकिन मैंने यह सुनिश्चित करने के लिए कि यह वास्तव में मामला है।
— user1417684
यह एक लंबे समय पहले किया था, envs और इस तरह के परीक्षण में दर्द का कारण बनता है। ओवरहेड के लायक नहीं है। यादृच्छिक नया वैश्विक नए लोगों को अनिश्चित
— ब्ले
और आप requireयह कार्य कैसे करते हैं ?
— डार्को मैकसिमोविक
5

यहाँ वास्तविक तरीका है जो मैं 6 महीने से अधिक समय से कर रहा हूँ। मैं प्रोजेक्ट में रूट रूट के रूप में नोड_मॉडल्स नामक एक फ़ोल्डर का उपयोग करता हूं, इस तरह से यह हमेशा उस फ़ोल्डर की तलाश करेगा जहां से मैं पूरी तरह से कॉल करता हूं:

  • node_modules
    • मेरी परियोजना
      • index.js मुझे आवश्यकता के बजाय ("myProject / someFolder / hey.js") की आवश्यकता हो सकती है ("./ someFolder / hey.js")
      • कुछ फ़ोल्डर जिसमें he.js होते हैं

यह तब अधिक उपयोगी होता है जब आप फ़ोल्डरों में नेस्टेड होते हैं और किसी फाइल लोकेशन को बदलने के लिए यह बहुत कम काम होता है, अगर इसे पूर्ण तरीके से सेट किया गया हो। मैं अपने पूरे ऐप में केवल 2 रिश्तेदार की आवश्यकता का उपयोग करता हूं ।

— Totty.js
स्रोत
4
मैं समान दृष्टिकोण का उपयोग करता हूं, सिवाय इसके कि मैं स्थानीय (परियोजना के) node_modulesको जोड़ता हूं /src, और /node_modulesविक्रेताओं को चीजों को अलग रखने के लिए छोड़ देता हूं । इसलिए मेरे पास /src/node_modulesस्थानीय कोड और /node_modulesविक्रेताओं के लिए है।
— मारियस बाल्कीटिस
33
IMHO नोड_मॉडल फ़ोल्डर केवल नोड_मॉड्यूल्स के लिए है। उस फ़ोल्डर के अंदर अपनी पूरी परियोजना को रखना एक अच्छा अभ्यास नहीं है।
— 18
2
@Mcas आप ऊपर के समान प्रभाव पाने के लिए एक विकल्प के रूप में क्या सुझाव देंगे?
— स्पीगलियो
3
@cspiegl आप NODE_PATHपर्यावरण चर का उपयोग कर सकते हैं
— क्रिस्टोफर
5

इसे प्राप्त करने का सबसे आसान तरीका इमो ऐप पर स्टार्टअप पर एक प्रतीकात्मक लिंक बनाना है node_modules/app(या जो भी आप इसे कहते हैं) जो इंगित करता है ../app। तब आप बस कॉल कर सकते हैंrequire("app/my/module") । प्रतीकात्मक लिंक सभी प्रमुख प्लेटफार्मों पर उपलब्ध हैं।

हालांकि, आपको अभी भी अपने सामान को छोटे, रख-रखाव वाले मॉड्यूल में विभाजित करना चाहिए जो npm के माध्यम से स्थापित हैं। आप अपने निजी मॉड्यूल को git-url के माध्यम से भी इंस्टॉल कर सकते हैं, इसलिए एक, अखंड ऐप-डायरेक्टरी होने का कोई कारण नहीं है।

— जोहान्स एवाल्ड
स्रोत
विंडोज पर समर्थन के लिए नोड और ओएस के अधिक गहन ज्ञान की आवश्यकता होती है। यह एक ओपन सोर्स प्रोजेक्ट के व्यापक उपयोग को सीमित कर सकता है।
— स्टीवन वचोन
आम तौर पर मैं इस पैटर्न का उपयोग लाइब्रेरी के लिए नहीं करूंगा (जो कि अधिकांश ओपन सोर्स प्रोजेक्ट हैं)। हालाँकि, npm बिल्ड हुक में इन सिम्लिंक को बनाना संभव है, ताकि उपयोगकर्ता को गहराई से ज्ञान न हो।
— जोहान्स इवाल्ड २५'१४
निश्चित रूप से, लेकिन विंडोज पर Node.js डिफ़ॉल्ट रूप से सहानुभूति का समर्थन नहीं करता है।
— स्टीवन वैचोन
4

अपनी स्वयं की परियोजना में आप किसी भी .js फ़ाइल को संशोधित कर सकते हैं जो रूट निर्देशिका में उपयोग की जाती है और process.envचर की संपत्ति में अपना रास्ता जोड़ते हैं । उदाहरण के लिए:

// in index.js
process.env.root = __dirname;

बाद में आप हर जगह संपत्ति का उपयोग कर सकते हैं:

// in app.js
express = require(process.env.root);
— AtraCaelus
स्रोत
4

एक और जवाब:

इस फ़ोल्डर संरचना की कल्पना करें:

  • node_modules
    • lodash
  • src
    • subdir
      • foo.js
      • bar.js
    • main.js

  • परीक्षण

    • test.js

तब test.js में , आपको इस तरह की फ़ाइलों की आवश्यकता होती है:

const foo = require("../src/subdir/foo");
const bar = require("../src/subdir/bar");
const main = require("../src/main");
const _ = require("lodash");

और main.js में :

const foo = require("./subdir/foo");
const bar = require("./subdir/bar");
const _ = require("lodash");

अब आप इसके साथ babel और babel-plugin-मॉड्यूल-रिज़ॉल्वर का उपयोग कर सकते हैं । 2 रूट फ़ोल्डर कॉन्फ़िगर करने के लिए babelrc फाइल:

{
    "plugins": [
        ["module-resolver", {
            "root": ["./src", "./src/subdir"]
        }]
    ]
}

अब आपको परीक्षणों में और src में उसी तरह से फ़ाइलों की आवश्यकता हो सकती है :

const foo = require("foo");
const bar = require("bar");
const main = require("main");
const _ = require("lodash");

और यदि आप es6 मॉड्यूल सिंटैक्स का उपयोग करना चाहते हैं :

{
    "plugins": [
        ["module-resolver", {
            "root": ["./src", "./src/subdir"]
        }],
        "transform-es2015-modules-commonjs"
    ]
}

तो आप में फ़ाइलें आयात परीक्षण और src इस तरह:

import foo from "foo"
import bar from "bar"
import _ from "lodash"
— सैनिक
स्रोत
3

examplesनिर्देशिका में node_modulesप्रोजेक्ट की जड़ के लिए एक प्रतीकात्मक लिंक के साथ नहीं हो सकता है, project -> ../../इस प्रकार उदाहरणों का उपयोग करने की अनुमति देता है require('project'), हालांकि यह मैपिंग को दूर नहीं करता है, यह स्रोत के require('project')बजाय का उपयोग करने की अनुमति देता हैrequire('../../') ।

मैंने इसका परीक्षण किया है, और यह v0.6.18 के साथ काम करता है।

की लिस्टिंग projectनिर्देशिका:

$ ls -lR project
project:
drwxr-xr-x 3 user user 4096 2012-06-02 03:51 examples
-rw-r--r-- 1 user user   49 2012-06-02 03:51 index.js

project/examples:
drwxr-xr-x 2 user user 4096 2012-06-02 03:50 node_modules
-rw-r--r-- 1 user user   20 2012-06-02 03:51 test.js

project/examples/node_modules:
lrwxrwxrwx 1 user user 6 2012-06-02 03:50 project -> ../../

की सामग्री index.jsप्रदान करती है की एक संपत्ति के लिए एक मूल्य exportsवस्तु और आह्वान console.logसंदेश में कहा गया है कि यह आवश्यक था के साथ। की सामग्री test.jsहै require('project')।

— डैन डी।
स्रोत
क्या आप अपने परीक्षण के सोर्सकोड को दिखा सकते हैं? ठीक है, और यह काम करेगा अगर मुझे इस तरह से ('project.a') की आवश्यकता होगी?
— टोटी.जेएस
आपका क्या मतलब है require('project.a')? मुझे लगता है कि इसका मतलब हो सकता है require('project/a'), हालांकि require('project').aयह भी संभव है?
— दान डी।
लेकिन आपके उदाहरण से मुझे प्रत्येक फ़ोल्डर में उन फ़ोल्डरों को बनाने की आवश्यकता होगी जहां एक मॉड्यूल है जिसे आवश्यकता विधि की आवश्यकता है। वैसे भी आपको फ़ोल्डर के आधार पर "../" के समय का ध्यान रखना होगा।
— टोटी.ज्स
वास्तव में लिंक को केवल node_modulesफ़ाइल के निकटतम माता-पिता में एक निर्देशिका में होना चाहिए और लिंक दोनों के लिए समान होगा। देखिए नोड्स.ओआरजी
— दान डी।
और उस स्थान से संबंधित होगा। उदाहरण के लिए project/node_modules/project -> ../:।
— दान डी।
2

अगर किसी को इस समस्या के आसपास एक और रास्ता ढूंढना है, तो यहां मेरा अपना योगदान है:

https://www.npmjs.com/package/use-import

मूल विचार: आप प्रोजेक्ट की जड़ में एक JSON फ़ाइल बनाते हैं जो शॉर्टहैंड नामों के लिए आपकी फ़ाइलपथ को मैप करती है (या आपके लिए इसे करने के लिए उपयोग-ऑटोमैटर प्राप्त करें )। फिर आप उन नामों का उपयोग करके अपनी फ़ाइलों / मॉड्यूलों का अनुरोध कर सकते हैं। इस तरह:

var use = require('use-import');
var MyClass = use('MyClass');

तो वहीं है।

— जॉन स्टाउट
स्रोत
2

मैं क्या करना पसंद करता हूं कि इसके लिए नोड_मॉड्यूल निर्देशिका से नोड कैसे लोड होता है।

यदि कोई मॉड्यूल "चीज़" को लोड करने की कोशिश करता है, तो कोई ऐसा कुछ करेगा

require('thing');

नोड तब 'नोड_मॉड्यूल ’डायरेक्टरी में' चीज’ डायरेक्टरी की तलाश करेगा।

चूंकि नोड_मॉडल आमतौर पर परियोजना की जड़ में है, इसलिए हम इस निरंतरता का लाभ उठा सकते हैं। (यदि नोड_मॉडल मूल में नहीं है, तो आपके पास निपटने के लिए अन्य स्व-प्रेरित सिरदर्द हैं।)

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

require('thing/../../');

फिर यदि हम / खुश निर्देशिका को एक्सेस करना चाहते हैं, तो हम ऐसा करेंगे।

require('thing/../../happy');

यद्यपि यह काफी हैक है, हालांकि मुझे लगता है कि अगर नोड_मॉडल लोड की कार्यक्षमता में परिवर्तन करता है, तो इससे निपटने के लिए बड़ी समस्याएं होंगी। यह व्यवहार सुसंगत रहना चाहिए।

चीजों को स्पष्ट करने के लिए, मैं ऐसा करता हूं, क्योंकि मॉड्यूल का नाम मायने नहीं रखता।

require('root/../../happy');

मैंने इसे हाल ही में angular2 के लिए उपयोग किया है। मैं एक सेवा को रूट से लोड करना चाहता हूं।

import {MyService} from 'root/../../app/services/http/my.service';
— justonpoints
स्रोत
अपने कोणीय संदर्भ के बारे में, एक मानक सीएलआई एप्लिकेशन के साथ, आप बस आयात src/app/my.serviceकर सकते हैं, टाइपस्क्रिप्ट फ़ाइलों के लिए गैर-सापेक्ष आयात का उपयोग करने के लिए आप VSC को भी कॉन्फ़िगर कर सकते हैं।
— प्लॉपी
2

मैंने यह छोटा पैकेज लिखा है जो आपको प्रोजेक्ट रूट से उनके रिश्तेदार पथ द्वारा पैकेजों की आवश्यकता होती है, बिना किसी वैश्विक चर या ओवरराइड डिफॉल्ट को पेश किए बिना

https://github.com/Gaafar/pkg-require

यह इस तरह काम करता है

// create an instance that will find the nearest parent dir containing package.json from your __dirname
const pkgRequire = require('pkg-require')(__dirname);

// require a file relative to the your package.json directory 
const foo = pkgRequire('foo/foo')

// get the absolute path for a file
const absolutePathToFoo = pkgRequire.resolve('foo/foo')

// get the absolute path to your root directory
const packageRootPath = pkgRequire.root()
— gafi
स्रोत
कभी-कभी मेरे पास मुख्य परियोजना में निजी पैकेज होते हैं, यह स्क्रिप्ट उसी के साथ टूट जाएगी। इसके अलावा, मुझे यकीन नहीं है कि मैं वेबपैक के साथ ठीक काम करूंगा (यदि आप नोड के साथ वेबपैक का उपयोग करते हैं तो जैसा कि मैं करता हूं)
— टोट्टी.जेएस
यदि आपके पास पैकेज फ़ाइलों के साथ नेस्टेड निर्देशिकाएँ हैं, तो प्रत्येक dir को केवल इसके पैकेज के भीतर फ़ाइलों की आवश्यकता होगी। क्या वह व्यवहार जो आप चाहते हैं? मैंने वेबपैक के साथ परीक्षण नहीं किया है।
— gafi
यह एक साधारण परियोजना के लिए पूरी तरह से काम करता है और अन्य उत्तरों की तुलना में कहीं अधिक आसान है।
— बक्सर
2

बस का पालन करना चाहते हैं महान जवाब से पाओलो मोरेटी और Browserify। यदि आप एक ट्रांसपिलर (जैसे, कोलाहल, टाइपस्क्रिप्ट) का उपयोग कर रहे हैं और आपके पास स्रोत के लिए अलग फ़ोल्डर हैं src/और जैसे और ट्रांसप्लड कोड हैं dist/, तो आप समाधानों की एक भिन्नता का उपयोग कर सकते हैं

node_modules

निम्नलिखित निर्देशिका संरचना के साथ:

app
  node_modules
    ... // normal npm dependencies for app
  src
    node_modules
      app
        ... // source code
  dist
    node_modules
      app
        ... // transpiled code

फिर आप बेपेल आदि को srcनिर्देशिका को ट्रांसपाइल करने दे सकते हैंdist ।

सिमलिंक

सिम्लिंक के उपयोग से हम घोंसले के शिकार के कुछ स्तरों से छुटकारा पा सकते हैं:

app
  node_modules
    ... // normal npm dependencies for app
  src
    node_modules
      app // symlinks to '..'
    ... // source code
  dist
    node_modules
      app // symlinks to '..'
    ... // transpiled code

कोलाहल के साथ एक चेतावनी --copy-फाइल--copy-files का झंडा babelअच्छी तरह से सिमलिंक के साथ सौदा नहीं करता है। यह ..सहानुभूति में नेविगेट कर सकता है और अंतहीन फ़ाइलों को पुन: देख सकता है। निम्न निर्देशिका संरचना का उपयोग करने के लिए एक वर्कअराउंड है:

app
  node_modules
    app // symlink to '../src'
    ... // normal npm dependencies for app
  src
    ... // source code
  dist
    node_modules
      app // symlinks to '..'
    ... // transpiled code

इस तरह, कोड के तहत srcअभी भी appहल हो जाएगा src, जबकि बेबल को अब सहानुभूति नहीं दिखाई देगी।

— user716468
स्रोत
धन्यवाद, लेकिन, मैं इस जादू को करने की सलाह नहीं दूंगा। पहले आप सभी आयात खो देंगे, वे आपके आईडीई द्वारा गणना नहीं किए जाएंगे। यदि आप प्रवाह प्रकार जैसे अन्य उपकरणों का उपयोग करते हैं तो यह ठीक से काम नहीं करेगा।
— टट्टी.जेएस
वास्तव में प्रवाह मेरे मामले में काम करता है, जो आश्चर्यजनक नहीं है क्योंकि समाधान मानक नोड मॉड्यूल रिज़ॉल्यूशन मॉडल पर निर्भर करते हैं, और सीमलिंक। तो यह वास्तव में समझने के लिए प्रवाह जैसे उपकरणों के लिए जादू नहीं है। लेकिन आईडीई अलग हैं।
— user716468
2

मैं किसी भी स्तर से फ़ाइलों की आवश्यकता के लिए एक ही सरलता की तलाश में था और मुझे मॉड्यूल-उर्फ मिला ।

बस स्थापित करें:

npm i --save module-alias

अपनी package.json फ़ाइल खोलें, यहाँ आप अपने रास्तों के लिए उपनाम जोड़ सकते हैं, उदाहरण के लिए

"_moduleAliases": {
 "@root"      : ".", // Application's root
 "@deep"      : "src/some/very/deep/directory/or/file",
 "@my_module" : "lib/some-file.js",
 "something"  : "src/foo", // Or without @. Actually, it could be any string
}

और बस अपने उपनाम का उपयोग करें:

require('module-alias/register')
const deep = require('@deep')
const module = require('something')
— तल्हा इमाम
स्रोत
1

मैंने "रेकीर" नामक एक नोड मॉड्यूल बनाया

यह आपको सापेक्ष रास्तों के उपयोग के बिना आवश्यकता होती है

https://npmjs.org/package/rekuire

यह उपयोग करने के लिए सुपर आसान है

— नदव लशम
स्रोत
1

हम इस समस्या से निपटने के लिए एक नया तरीका आजमाने जा रहे हैं।

स्प्रिंग और गाइस जैसी अन्य ज्ञात परियोजनाओं से उदाहरण लेते हुए, हम एक "संदर्भ" ऑब्जेक्ट को परिभाषित करेंगे जिसमें सभी "आवश्यकता" कथन होंगे।

यह ऑब्जेक्ट तब उपयोग के लिए अन्य सभी मॉड्यूल को पास किया जाएगा।

उदाहरण के लिए

var context = {}

context.module1 = require("./module1")( { "context" : context } )
context.module2 = require("./module2")( { "context" : context } )

इसके लिए हमें प्रत्येक मॉड्यूल को एक फ़ंक्शन के रूप में लिखना होगा जो ऑप्स प्राप्त करता है, जो हमें वैसे भी सबसे अच्छा अभ्यास के रूप में दिखता है। 

module.exports = function(context){ ... }

और फिर आपको सामान की आवश्यकता के बजाय संदर्भ को संदर्भित करना होगा।

var mod1Ref = reference.moduel1;

यदि आप चाहते हैं, तो आप आवश्यकता वाले बयानों को करने के लिए आसानी से एक लूप लिख सकते हैं

var context = {};
var beans = {"module1" : "./module1","module2" : "./module2" }; 
for ( var i in beans ){
    if ( beans.hasOwnProperty(i)){
         context[i] = require(beans[i])(context);
    }
};

यह जीवन को आसान बनाना चाहिए जब आप मॉक (परीक्षण) करना चाहते हैं और अपने कोड को एक पैकेज के रूप में पुन: प्रयोज्य बनाते समय अपनी समस्या का समाधान भी करते हैं।

आप सेम इनिशियलाइज़ेशन कोड का भी उपयोग कर सकते हैं। उदाहरण के लिए, आपकी main.jsफ़ाइल ऐसी दिख सकती है

var beans = { ... }; // like before
var context = require("context")(beans); // this example assumes context is a node_module since it is reused..

यह विधि बाहरी पुस्तकालयों पर भी लागू होती है, हर बार हमें उनके नामों की हार्ड कोड की आवश्यकता नहीं होती है - हालांकि, उन्हें एक विशेष उपचार की आवश्यकता होगी क्योंकि उनके निर्यात ऐसे कार्य नहीं हैं जो संदर्भ की उम्मीद करते हैं।

बाद में हम फलियों को भी कार्यों के रूप में परिभाषित कर सकते हैं - जो हमें requireपर्यावरण के अनुसार अलग-अलग मॉड्यूलों की अनुमति देगा - लेकिन यह इस धागे के दायरे से बाहर है।

— आदमी मोगरीबी
स्रोत
1

मुझे इसी समस्या से परेशानी हो रही थी, इसलिए मैंने एक पैकेज लिखा जिसमें शामिल हैं ।

अपनी package.json फ़ाइल का पता लगाने के माध्यम से अपनी परियोजना के रूट फ़ोल्डर का पता लगाने वाले हैंडल को शामिल करें , फिर आप जिस पथ तर्क को देते हैं, उसे आप सभी के लिए मूल पथ की आवश्यकता के बिना (आवश्यक) पास करते हैं। मैं इसकी आवश्यकता के लिए प्रतिस्थापन के रूप में कल्पना नहीं करता (), लेकिन गैर-पैक / गैर-तृतीय-पक्ष फ़ाइलों या पुस्तकालयों को संभालने के लिए एक उपकरण। कुछ इस तरह

var async = require('async'),
    foo   = include('lib/path/to/foo')

मुझे उम्मीद है कि यह उपयोगी हो सकता है।

— एंथोनी निकोल्स
स्रोत
1

यदि आपके ऐप की एंट्री पॉइंट जेएस फाइल (यानी जिसे आप वास्तव में "नोड" पर चलाते हैं) आपके प्रोजेक्ट रूट डायरेक्टरी में है, तो आप रूटपाथ एनपीएम मॉड्यूल के साथ यह आसानी से कर सकते हैं । बस के माध्यम से इसे स्थापित करें

npm install --save rootpath

... तो प्रविष्टि बिंदु js फ़ाइल के शीर्ष पर, जोड़ें: 

require('rootpath')();

से उस समय के बाद सभी की आवश्यकता होती है कॉल अब परियोजना जड़ के सापेक्ष हैं - जैसे require('../../../config/debugging/log'); हो जाता है require('config/debugging/log');(जहां config फ़ोल्डर परियोजना जड़ में है)।

— एंड्रयू फॉल्कनर
स्रोत
1

सरल लाइनों में, आप अपने खुद के फ़ोल्डर को मॉड्यूल कह सकते हैं:

इसके लिए हमें चाहिए: वैश्विक और ऐप-मॉड्यूल-पथ मॉड्यूल

यहां "ऐप-मॉड्यूल-पथ" मॉड्यूल है, यह आपको Node.js मॉड्यूल खोज पथ में अतिरिक्त निर्देशिकाओं को जोड़ने में सक्षम बनाता है और "वैश्विक" है, जो कुछ भी आप इस ऑब्जेक्ट से जोड़ते हैं वह आपके ऐप में हर जगह उपलब्ध होगा।

अब इस स्निपेट पर एक नज़र डालें:

global.appBasePath = __dirname;

require('app-module-path').addPath(appBasePath);

__dirname नोड की वर्तमान चल रही निर्देशिका है। आप मॉड्यूल के लिए पथ खोजने के लिए यहां अपना रास्ता दे सकते हैं।

— ट्रोजन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.