क्लासिक निर्भरता प्रबंधन दृष्टिकोण आवश्यकताएँ की तुलना में

नमस्ते विश्व

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

यह विधि इसकी सादगी में अन्य दृष्टिकोणों से भिन्न है: निर्भरताएं मॉड्यूल की शुरुआत में फ़ाइल के लिए सटीक पथ द्वारा सूचीबद्ध होती हैं, मॉड्यूल बॉडी में कोड होता है जो मॉड्यूल की निर्भरता को लोड करने के बाद चलता है।

Helios कर्नेल के सिद्धांत का पालन करता है KISS , इसलिए यहाँ है कि आज पुस्तकालय के प्रबंधन की निर्भरता से उम्मीद करने के लिए स्वीकार किए जाते हैं कर रहे हैं कुछ सुविधाएं गुम। हेलिओस कर्नेल का उपयोग करते समय, विभिन्न मॉड्यूल के लिए पथ खोजने के लिए नियमों के साथ एक कॉन्फ़िगरेशन का वर्णन करना आवश्यक नहीं है, या किसी विशेष ऑब्जेक्ट के माध्यम से लाइब्रेरी फ़ंक्शन को निर्यात करना है। लेकिन यह लाइब्रेरी सिर्फ इसलिए लिखी गई क्योंकि मैं सिर्फ नए मॉड्यूलेशन को निर्दिष्ट करते हुए, कूल फीचर्स में चलने के बिना, आवश्यक मॉड्यूल कनेक्ट करना और कोड लिखना चाहता था।

हेलिओस कर्नेल रनटाइम में निर्भरता के गतिशील लोडिंग (और अनलोडिंग) का समर्थन करता है, और स्वयं लाइब्रेरी और मॉड्यूल प्रारूप नोड्ज और ब्राउज़र वातावरण के बीच संगत है - अर्थात, मॉड्यूल को संशोधन या अनुवाद के बिना उपयोग किया जा सकता है।

यह आलेख आवश्यकता प्रबंधन का उपयोग करते हुए निर्भरता प्रबंधन के साथ क्लासिक हेलिओस कर्नेल दृष्टिकोण की तुलना करता है और दिखाता है कि हेलिओस कर्नेल दृष्टिकोण जटिलता से कैसे बचा जाता है।

परिचय

हेलीओस कर्नेल की निम्नलिखित विशेषताएं हैं:

• मॉड्यूल हेडर में शामिल () फ़ंक्शन का उपयोग करके निर्भरताएं परिभाषित की जाती हैं। फ़ाइल के लिए सटीक सापेक्ष पथ का उपयोग तर्क के रूप में किया जाता है।
  
• निर्भरताओं को सूचीबद्ध करने के बाद, मॉड्यूल कोड वाले init () फ़ंक्शन को परिभाषित किया गया है। सभी आश्रितों को लोड करने के बाद इस कोड को निष्पादित किया जाएगा
  

इसलिए, दो मॉड्यूल के बीच संबंध का वर्णन इस प्रकार है।

लाइब्रेरी मॉड्यूल myLibrary.js, कुछ कार्यक्षमता घोषित करता है:

init = function() { //  ()   myLibrary = {}; //   myLibrary.writeHello = function() { console.log("Hello World!"); } } 

और इस पुस्तकालय को जोड़ने और उपयोग करने वाला मॉड्यूल:

 include("path/to/myLibrary.js"); init = function() { //        myLibrary.writeHello(); } 

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

लेकिन अगर आपको केवल मॉड्यूल के स्थानीय चर निर्धारित करने की आवश्यकता है, तो आप इसके लिए init () फ़ंक्शन के दायरे का उपयोग कर सकते हैं।

आगे मैं ऐसे उदाहरण दूंगा जिसमें हेलिओस कर्नेल का उपयोग करने से आवश्यकता से अधिक कोड आसान हो जाता है

मॉड्यूल विवरण

निर्भरता के साथ मॉड्यूल के विवरण का प्रारूप इस तरह दिखता है:

RequireJS	हेलिओस कर्नेल
define( // ['fooLibrary', 'barLibrary'], function( foo, bar ){ // foo.doSomething(); } );	// include("path/to/fooLibrary.js"); include("path/to/barLibrary.js"); init = function() { // foo.doSomething(); }

आवश्यकताएँ ऑब्जेक्ट्स में लाइब्रेरी ऑब्जेक्ट्स को निर्यात करने की विधि आपको दो बार निर्भरता का नाम निर्दिष्ट करने के लिए मजबूर करती है - एक बार मॉड्यूल का नाम जहां निर्भरता स्थित है, दूसरी बार - उस तर्क का नाम जहां यह निर्भरता निर्यात की जाएगी।

जब अधिक निर्भरता होती है, तो यह आवश्यकता मॉड्यूल को अधिक पठनीय बनाता है:

RequireJS	हेलिओस कर्नेल
define( [ 'dep1', 'dep2', 'dep3', 'dep4', 'dep5', 'dep6', 'dep7' ], function ( dep1, dep2, dep3, dep4, dep5, dep6, dep7) { // ... } );	include("deps/dep1.js"); include("deps/dep2.js"); include("deps/dep3.js"); include("deps/dep4.js"); include("deps/dep5.js"); include("deps/dep6.js"); include("deps/dep7.js"); include("deps/dep8.js"); init = function() { // ... }

इस तरह के कोड को सरल बनाने के लिए, आवश्यकताएँ भी निर्भरता का वर्णन करने के लिए एक वैकल्पिक तरीका लेकर आईं , सरल कॉमोनजेएस । इस तकनीक का उपयोग करके, आप निम्नानुसार निर्भरता का वर्णन कर सकते हैं:

 define( [ 'dep1', 'dep2', 'dep3', 'dep4', 'dep5', 'dep6', 'dep7' ], function (require) { var dep1 = require('dep1'), dep2 = require('dep2'), dep3 = require('dep3'), dep4 = require('dep4'), dep5 = require('dep5'), dep6 = require('dep6'), dep7 = require('dep7'); // ... } }); 

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

हेलिओस कर्नेल इस सब से बचता है। एक अतिरिक्त निर्भरता में केवल एक उल्लेख के साथ शामिल () की आवश्यकता होती है।

विधानसभा मॉड्यूल बनाना

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

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

हालाँकि, आवश्यकताएँ के मामले में, अभी भी आवश्यक निर्भरता और सामान्य मॉड्यूल के निर्यात किए गए ऑब्जेक्ट के माध्यम से उन्हें "आगे" निर्यात करना आवश्यक होगा।

हेलिओस कर्नेल के मामले में, बस निर्भरता को सूचीबद्ध करना पर्याप्त है:

RequireJS	हेलिओस कर्नेल
define( 'depCommon', [ 'dep1', 'dep2', 'dep3' ], function( dep1, dep2, dep3 ) { return { dep1 : dep1, dep2 : dep2, dep3 : dep3 } } );	include('deps/dep1.js'); include('deps/dep2.js'); include('deps/dep3.js');

हेलिओस कर्नेल प्रारूप में लिखे गए सामान्य मॉड्यूल के लिए, आपको init () फ़ंक्शन का वर्णन करने की आवश्यकता नहीं है। यह पठनीयता को भी सरल करता है - यदि आप इस मॉड्यूल के कोड को देखते हैं, तो आप तुरंत देख सकते हैं कि यह कोई क्रिया नहीं करता है, लेकिन केवल अतिरिक्त मॉड्यूल को जोड़ता है।

लेकिन आवश्यकताएँ जेएसजेएस के साथ एक सामान्य मॉड्यूल के मामले में, आपको इसके निर्यात के सभी मामलों को फिर से लिखना होगा। यदि पहले व्यक्तिगत निर्यात किए गए भागों को dep1, dep2, ... के रूप में संबोधित किया जाना था, तो अब इसे depCommon.dep1, depCommon.dep2, ... से बदलना होगा।

नियमित जावास्क्रिप्ट पुस्तकालयों का उपयोग करना आसान है

हम उन पुस्तकालयों के बारे में बात कर रहे हैं जिन्हें स्क्रिप्ट टैग का उपयोग करके html पेज से जोड़ा जाना चाहिए।

हेलिओस कर्नेल मॉड्यूल का प्रारूप नियमित पुस्तकालयों के बहुत करीब है, क्योंकि इनिट () फ़ंक्शन में कोई भी कोड हो सकता है। इसलिए, एक नियमित लाइब्रेरी को मॉड्यूल में बदलने के लिए, इसे इनिट () फ़ंक्शन की परिभाषा में लपेटने के लिए पर्याप्त है, और उसके बाद इसमें शामिल () का उपयोग करके जोड़ा जा सकता है।

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

वेब और नोडज के बीच आसान पोर्टिंग

एक नोड वातावरण में सर्वर पर रिक्जेस्ट्स मॉड्यूल का उपयोग करने के लिए, आप r.js लाइब्रेरी का उपयोग कर सकते हैं, जिससे आप ऐसे मॉड्यूल को नोडज से कनेक्ट कर सकते हैं।

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

हेलिओस कर्नेल इस कार्य को इस तथ्य के कारण सरल बनाता है कि मॉड्यूल दोनों प्लेटफार्मों पर परिवर्तन और रूपांतरण के बिना काम करते हैं।

वेबसाइट: http://asvd.imtqy.com/helios-kernel/
कोड: https://github.com/asvd/helios-kernel/releases/download/v0.9.5/helios-kernel-0.9.5.tar.gz
गिथब: https://github.com/asvd/helios-kernel