आत्मा: Node.js MVC फ्रेमवर्क

हाय दोस्तों! अब से, मैं node.js



लिए अपना स्वयं का एमवीसी ढांचा बनाने के विवरण के साथ लेखों की एक श्रृंखला शुरू करना चाहता node.js



, जिसका नाम आत्मा होगा।



पहले लेख में चार भाग होंगे:

1. रूपरेखा का विचार और मिशन

2. सर्वर सेटअप

3. एक रूपरेखा ढांचा बनाना

4. एक उन्नत और सुविधाजनक राउटर बनाना



मैं आपको तुरंत चेतावनी देता हूं कि लेख बहुत बड़ा है, जिसमें बहुत सारे पाठ और कोड के बड़े ब्लॉक हैं।

फ्रेमवर्क का विचार और मिशन

प्रेरणा, मनोदशा और समय (जो अभी पर्याप्त नहीं है) के रूप में आत्मा धीरे-धीरे विकसित होगी। यद्यपि आलोचना और सुझावों का स्वागत है - मैं इसे अपनी दृष्टि के अनुसार विकसित करूंगा, और यदि पहले लेख को समुदाय द्वारा गर्मजोशी से स्वीकार किया जाता है - तो लेख के रूप में प्रत्येक तार्किक अनुभाग का विवरण देना।



मुख्य लक्ष्य प्रशिक्षण और मंच में रुचि को बढ़ावा देना है। मुझे बहुत खुशी होगी अगर किसी ने परियोजना को छोड़ दिया और इसके आधार पर एक रूपरेखा बनाई, तो आप मुझे नैतिक समर्थन के लिए भी बदल सकते हैं। फिर भी, यदि आप अपने कार्यों के विस्तृत विवरण के साथ आत्मा के विकास में भाग लेना चाहते हैं, तो अपने आप को सकारात्मक कैसे कमाएं (वास्तविक) कर्म - shocksilien@gmail.com पर लिखें, हम चर्चा करेंगे)।



Github पर सभी स्रोत कोड github.com/theshock/spirit पर उपलब्ध होंगे



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



उदाहरणों में, मैं मानता हूं कि हम डेबियन सिस्टम का उपयोग कर रहे हैं और उपयोगकर्ता की होम निर्देशिका "/ होम / स्पिरिट" है। जब तक अन्यथा निर्दिष्ट नहीं किया जाता है तब तक साइट को soul.example.com पर होस्ट किया जाएगा

सर्वर सेटअप

नेगनेक्स और अपाचे नोड के विपरीत। बॉक्स से बाहर नोड्स स्वचालित रूप से सर्वर पर शुरू नहीं होता है और कुछ कॉन्फ़िगरेशन आवश्यक है।



सबसे पहले, init



की मदद से हम एक डेमॉन बनाते हैं, और फिर monit



की मदद से monit



कि क्या सर्वर क्रैश हो गया है। इस विषय को लंबे समय से चित्रित किया गया है, जानकारी Google में पाई जा सकती है, उदाहरण के लिए, साइट नोडजेसरू पर । इस दृष्टिकोण को नोड.जेएस पर लिंक रिड्यूसर के उदाहरण पर व्यक्तिगत रूप से मेरे द्वारा परीक्षण और अनुमोदित किया गया है, जो कुछ घंटों में 15,000 से अधिक लिंक कम कर देता है और फ़्लिप भी नहीं करता है, यह अभी भी (लगभग 20 दिन) खड़ा है।



दूसरा कदम एक दृश्य के रूप में नेग्नेक्स है।

 server { listen 80; server_name spirit.example.com; access_log /home/spirit/example-app/logs/nginx.access.log; location / { proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_pass http://127.0.0.1:8124/; } location ~* \.(html|js|ico|gif|jpg|png|css|doc|xml|rar|zip|swf|avi|mpg|flv|mpeg|wmv|ogv|oga|ogg)$ { root /home/spirit/example-app/public; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हम बहुत सरल कोड देखते हैं - नगीनक्स हमारे नोड के लिए स्टैटिक्स को छोड़कर सब कुछ रीडायरेक्ट करता है। जेएस, जो पोर्ट 8124 (या जो भी आप निर्दिष्ट करते हैं) पर स्थित होगा। स्टैटिक्स को नोड के किसी भी भागीदारी के बिना दिया जाएगा। सीधे नगीनेक्स के साथ।

एक ढांचा कंकाल बनाएँ

इसलिए, हम इस तरह की निर्देशिका संरचना के लिए प्रयास करेंगे:

/home/spirit/

├ lib/

│ ├ mysql-libmysqlclient/

│ ├ spirit/

│ └ MooTools.js

├ example-app/

│ ├ engine/

│ │ ├ classes/

│ │ └ init.js

│ ├ logs/

│ └ public/

└ another-example-app/

├ engine/

│ ├ classes/

│ └ init.js

├ logs/

└ public/



इस आरेख में दो प्रमुख विचार देखे जा सकते हैं:

1. सभी पुस्तकालय, incl। और आत्मा स्वयं अनुप्रयोगों से अलग निर्देशिकाओं में स्थित होगी - यह आपको सभी पुस्तकालयों की सूची को दोहराए बिना एक ही सर्वर पर कई एप्लिकेशन रखने की अनुमति देगा।

2. प्रत्येक एप्लिकेशन में दो प्रमुख निर्देशिकाएं होती हैं - इंजन, जिसमें हम सर्वर लॉजिक और पब्लिक को स्टोर करेंगे, जिसकी सभी सामग्री हम क्लाइंट को देंगे। यह सर्वर कोड को बाहर से किसी भी अतिक्रमण से बचाएगा और विभिन्न तर्क के बीच अंतर करेगा।



lib



निर्देशिका में हम उन सभी पुस्तकालयों को डंप करेंगे जिनकी हमें आवश्यकता है।



आत्मा संशोधित मूओटॉल्स पर आधारित है, मैंने इसे लिंक शॉर्टनर के बारे में विषय में कैसे जोड़ा। कनेक्शन में आसानी के लिए, मैंने MooTools.More Class को कनेक्ट किया। यह सीधे lib/MooTools.js



फ़ाइल से जुड़ता है , जो बिना संदर्भ खोए तर्क के तरीकों को पारित करने की अनुमति देगा और htmlEscape



, ucfirst



और lcfirst



को जोड़कर स्ट्रिंग प्रोटोटाइप का थोड़ा विस्तार करेगा।

आवेदन आरंभीकरण

कोड में पुस्तकालयों को जोड़ना (आवश्यक) निम्न विधियों में से एक में आता है:

1. नाम से। उदाहरण के लिए, require( 'fs' )



। इस प्रकार, हम कर्नेल को वायर्ड किए गए पुस्तकालयों में से एक को जोड़ते हैं और प्रलेखन में वर्णित हैं ।

2. वर्तमान फ़ाइल के सापेक्ष पथ के अनुसार। उदाहरण के लिए, require( './classes/foo' )



या require( '../lib/mootools.js' )





3. परम पथ। उदाहरण के लिए, require( '/home/spirit/lib/mootools' )







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

 // __dirname -  ,   //  ,      var libPath = __dirname + '/../../lib'; //  : /home/spirit/lib //            // fs.realpathSync(libPath),     //    MooTools   , //      require(libPath + '/MooTools').apply(GLOBAL); //       var spirit = require(libPath + '/spirit/spirit') .createSpirit(__dirname, libPath); //     -   //    ,   require('http').listen spirit.listen("127.0.0.1:8124");
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हम मुख्य वर्ग लिखते हैं

निर्यात के लिए इसे संभव बनाने के लिए हम जो कुछ भी करना चाहते हैं - हमें निर्यात वस्तु में जोड़ना होगा। यही है, अगर हम var foo = new (require( './bar' ). bar );



, bar.js



फ़ाइल में हमें यह करना होगा: exports . bar = new Class({ /* ... */ });



exports . bar = new Class({ /* ... */ });



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



बार दोहराने की require



), लेकिन अंत में हम इसे बदल देंगे ताकि यह हमारे हाथों में खेले - यह सुविधाजनक और सुंदर होगा। इसलिए, फ्रेमवर्क के मुख्य वर्ग को बनाने का कार्य:

 exports['createSpirit'] = function (projectPath, libPath) { return new Spirit(projectPath, libPath); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कक्षा में ही, हम निम्नलिखित विचारों को लागू करते हैं:

1. सभी कक्षाएं app/classes



और lib/spirit/classes





2. जब नाम से एक वर्ग लोड हो रहा है, तो हम पहले आवेदन निर्देशिका की जांच करते हैं, फिर फ्रेमवर्क (जब तक कि अन्यथा नहीं कहा गया है)। यदि आवश्यक हो तो इस तरह से आप फ्रेमवर्क कक्षाओं को ओवरलोड कर सकते हैं (यह हिस्सा बाद में वर्णित किया जाएगा)

3. भरी हुई कक्षाएं - कैश्ड होती हैं, जो एफएस के लिए अनावश्यक पहुंच से बचेंगी (या इसे नोड.जेएस में कैश किया गया है?)

4. कक्षा अन्य सभी कार्यों के लिए शुरुआती बिंदु होगी।



मैं पेस्टिन पर क्लास कोड पोस्ट करूंगा, लेकिन यहां मैं केवल इंटरफ़ेस का वर्णन करूंगा

pastebin.com/0b14MEbe

 var Spirit = new Class({ Binds: ['hit', 'load'], initialize : function (String projectPath, String libPath) { }, load : function (String className, Boolean fromSpirit) { //   load    , : // spirit.load('Controllers.User'); //     ,  ,    -   //  fromSpirit    //  ,    }, loadLib : function (libName) { //     , : // spirit.loadLib('mysql-libmysqlclient') //     libPath //           }, //       hit : function (req, res) { }, listen : function (port, url) { //     //  .listen(8124, '127.0.0.1')  //  .listen('127.0.0.1:8124') } }); var load = function (path, className) { // some code is here //         //    Spirit.      ? //  ! return data[className](this); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इसलिए दृष्टिकोण कक्षाएं बनाने की अगली शैली की ओर जाता है।

 exports['Name.Space.ClassName'] = function (spirit) { return new Class({ method : function (msg) { this.response.writeHead(200, {'Content-Type': 'text/plain'}); this.response.end(msg); } }); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह अभी तक स्पष्ट नहीं है कि यह क्यों आवश्यक है।

 exports['Helper.AnotherClass'] = function (spirit) { var mysql = spirit.loadLib('mysql-libmysqlclient'); return new Class({ Extends : spirit.load('Name.Space.ClassName'), start : function (msg) { this.method('Started'); }, query : function () { // using mysql } }); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और आप Name.Space.ClassName



को कैसे शामिल Name.Space.ClassName



? require( '../Name/Space/ClassName' );



? और यदि आप कक्षा को दूसरी जगह स्थानांतरित करते हैं, तो क्या आप सभी तरीकों को फिर से लिखेंगे? क्या पुस्तकालय पूर्ण पथ में प्रवेश करके लोड किया जाएगा?

आइए एक और उदाहरण देखें। मान लीजिए कि हमारे ढांचे में एक राउटर वर्ग है जो हर हिट को संसाधित करता है:

 exports['Router'] = function (spirit) { return new Class({ // .. hit : function (request, response) { // some code }, // .. }); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हम हिट लॉगिंग शुरू करना चाहते हैं। हम अपने आवेदन की निर्देशिका में राउटर वर्ग की घोषणा करते हैं:

 exports['Router'] = function (spirit) { var Logger = spirit.load('Logger'); var logger = new Logger; return new Class({ Extends : spirit.load('Router', true), hit : function (request, response) { logger.log('hit!'); this.parent(request, response); }, // .. }); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस प्रकार, हम कक्षाओं का विस्तार कर सकते हैं, रूपरेखा के व्यवहार को बदल सकते हैं और स्रोत कोड में नहीं जा सकते हैं।

एक राउटर बनाएं

राउटर इसे अनुरोधों को पार्स करेगा और निष्पादन के लिए वांछित नियंत्रक को देगा।

रूटिंग निम्नानुसार होगी:

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

2. यदि मार्ग पैरा 2 में नहीं पाया गया है, तो पता स्लैश से टूट गया है और निकटतम को नियंत्रकों के बीच खोजा गया है। पते पर url / AA / BB / CC / DD / EE, नियंत्रक AA.BB.CC.DD.EE को पहले खोजा जाता है, फिर AA.BB.CC.DD, और इसी तरह, जब तक कि वांछित नहीं मिल जाता है। यदि ऐसा कोई नियंत्रक नहीं है, तो सूचकांक नियंत्रक प्रतिस्थापित किया जाता है। यदि कोई AA.BB.CC.DD नियंत्रक नहीं है, लेकिन AA.BB.CC.DD.Index है, तो उसका चयन किया जाएगा। फिर एक विधि का चयन किया जाता है और बाकी सब कुछ तर्क के रूप में पारित किया जाता है।



सभी आरंभिक कक्षाओं को आवेदन आरंभीकरण के दौरान लोड किया जाएगा, जो प्रत्येक अनुरोध के साथ अनावश्यक गलतफहमी से बचेंगे।



हमारे आवेदन की निर्देशिका कुछ इस तरह दिखाई देगी:

/home/spirit/example-app/

├ engine/

│ ├ classes/

│ │ ├ controllers/

│ │ │ ├ Admin/

│ │ │ │ ├ Articles.js

│ │ │ │ └ Index.js

│ │ │ ├ Man/

│ │ │ │ ├ Index.js

│ │ │ │ └ Route.js

│ │ │ ├ Index.js

│ │ │ └ Users.js

│ │ └ Controller.js

│ └ init.js

├ logs/

└ public/



हमारी एप्लिकेशन इनिट फ़ाइल में निम्नलिखित कोड जोड़ें, जो मैनुअल मार्गों के लिए दृष्टिकोण प्रदर्शित करेगा। : A, D:, H,: W निम्नलिखित पैटर्न के अनुरूप हैं: [az], [0-9], [0-9a-f], [0-9a-z], क्रमशः। यह सुनिश्चित करने के लिए <और> जिम्मेदार हैं कि यह अभिव्यक्ति क्रमशः शुरुआत और पते के अंत में दिखाई देती है। इस प्रकार, एक अभिव्यक्ति जैसे कि </test-:A>



url से मेल नहीं खाती " /test-abc123



", जबकि एक अभिव्यक्ति /test-:A



इस url से मेल खाती है। सभी टेम्पलेट्स को एक सरणी में जोड़ा जाता है और एक तर्क के रूप में पारित किया जाता है जब नियंत्रक विधि कहा जाता है। यदि कोई argsMap है, तो हैश प्रसारित होता है। उदाहरण के लिए, " /articles-15/page-3



" के पते के साथ, पहला तर्क एक सरणी [15, 3]



, लेकिन यदि आप argsMap : ['id', 'page']



पास argsMap : ['id', 'page']



, हैश {id:15, page:3}



विधि से पारित हो जाएगा। {id:15, page:3}



।

 spirit.createRouter() .addRoutes( { route : "</article-:D/page-:D" , contr : 'Man.Route:articleWithPage' , argsMap : ['id', 'page'] }, { route : "</article-:D" , contr : 'Man.Route:article' , argsMap : ['id'] }, { route : "</~:W>" , contr : 'Man.Route:user' }, { route : "</hash-:H>" , contr : 'Man.Route:hash' } );
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और यहां नियंत्रक है जो इस कोड के साथ काम करता है (ऊपर चित्र में इसे बोल्ड में हाइलाइट किया गया है):

 exports['Controllers.Man.Route'] = function (spirit) { return new Class({ Extends : spirit.load('Controller'), indexAction : function () { this.exit('(Man.Route) index action'); }, testAction : function () { this.exit('(Man.Route) test action'); }, articleWithPageAction : function (args) { this.exit('(Man.Route) article #' + args.id + ', page #' + args.page); }, articleAction : function (args) { this.exit('(Man.Route) article #' + args.id); }, hashAction : function (args) { this.exit('(Man.Route) hash: ' + args[0]); }, userAction : function (args) { this.exit('(Man.Route) user: ' + args[0]); } }); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और अभिभावक नियंत्रक, जिसका उपयोग हम सभी बच्चों को exit



विधि निर्धारित करने के लिए करेंगे:

 exports['Controller'] = function (spirit) { return new Class({ exit : function (msg) { this.response.writeHead(200, {'Content-Type': 'text/plain'}); this.response.end(msg); } }); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

पहले आपको आत्मा वर्ग का विस्तार करने की आवश्यकता है, हम राउटर के कंधों पर पूरी तरह से अनुरोधों के विश्लेषण को स्थानांतरित करते हैं:

  createRouter : function () { var Router = this.load('Router'); var router = new Router(); router.spirit = this; this.router = router; router.init(); return router; }, hit : function (req, res) { this.router.hit(req, res); },
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

राउटर खुद भी विशेष रूप से ढेर नहीं किया जाएगा और अपने डिप्टी को मुख्य काम देगा:

 exports['Router'] = function (spirit) { var RouterHelper = spirit.load('Router.Helper'); return new Class({ init : function () { var path = this.spirit.requirePath + 'Controllers'; this.routerHelper = new RouterHelper(this); this.routerHelper.requireAll(path); }, hit : function (request, response) { var contrData = this.routerHelper.route(request); var contr = contrData.contr; contr.spirit = this.spirit; contr.request = request; contr.response = response; if (typeof contr.before == 'function') contr.before(); contr[contrData.method](contrData.args); if (typeof contr.after == 'function') contr.after(); }, addRoutes : function () { var rh = this.routerHelper; rh.addRoutes.apply(rh, arguments); } }); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 var fs = require('fs'); exports['Router.Helper'] = function (spirit) { var RouterPlain = spirit.load('Router.Plain'); var RouterRegexp = spirit.load('Router.Regexp'); return new Class({ initialize : function (router) { this.router = router; this.plain = new RouterPlain(this); this.regexp = new RouterRegexp(this); }, route : function (request) { var url = request.url; return this.regexp.route(url) || this.plain.route(url); }, requireAll : function (path) { var files = fs.readdirSync(path); for (var i = 0; i < files.length; i++) { var file = path + '/' + files[i]; var stat = fs.statSync(file); if (stat.isFile()) { this.addController(file); } else if (stat.isDirectory()) { this.requireAll(file); } } this.checkAllIndexActions(); }, //       regexp  addRoutes : function (routes) {}, //  ".js"       removeExt : function (file) {}, //      indexAction checkAllIndexActions : function () {}, //       addController : function (file) {}, //     false,   createController : function (name) {} }); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सबसे पहले, आपको addRoutes



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

 exports['Router.Regexp'] = function (spirit) { return new Class({ initialize : function (routerHelper) { this.routerHelper = routerHelper; }, route : function (url) { //            for (var i = 0; i < this.routes.length; i++) { var route = this.routes[i]; //           //      lastIndex,  //        , //   route.regexp.lastIndex = 0; var result = route.regexp.exec(url); if (result) { return { contr : this.routerHelper .createController(route.contr.name), method : route.contr.method, args : this.regexpRouteArgs(result, route.argsMap) }; } } return false; }, routes : [], addRoute : function (route, controller, argsMap) { }, addRoutes : function (hash) { }, //     ,   addRoutes //         , //  ( )) -    regexpContr : function (string) { var parts = string.split(':'); var method = parts.length > 0 ? parts[1] + 'Action' : 'indexAction'; var contr = 'Controllers.' + parts[0]; // ... }, //         //      // ,        regexpRoute : function (route) { var re = new RegExp(); re.compile(this.prepareRegexp(route), 'ig'); return re; }, replaces : { A : '([az]+)', D : '([0-9]+)', H : '([0-9a-f]+)', W : '([0-9a-z]+)', }, prepareRegexp : function (route) { return route .escapeRegExp() .replace(/>$/, '$') .replace(/^</, '^') .replace(/:([ADHW])/g, function ($0, $1) { return this.replaces[$1]; }.bind(this)); }, //  ,   regexp.exec  //    input  lastIndex  //  ,   argsMap regexpRouteArgs : function (result, argsMap) { }, }); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जब नियमित अभिव्यक्तियों के लिए राउटर काम नहीं करता था, हम डिफ़ॉल्ट रूप से राउटर का उपयोग करते हैं:

 var url = require('url'); exports['Router.Plain'] = function (spirit) { return new Class({ initialize : function (routerHelper) { this.routerHelper = routerHelper; }, route : function (url) { var parts = this.getControllerName(url); var controller = this.routerHelper.createController(parts.name); var method = 'indexAction'; if (parts.args.length) { var action = parts.args[0].lcfirst(); //    -      //     -  ,  -  indexAction if (typeof controller[action + 'Action'] == 'function') { method = action + 'Action'; parts.args.shift(); } } return { contr : controller, method : method, args : parts.args }; }, getControllerName : function (url) { var controllers = this.routerHelper.controllers; //  pathname       var path = this.splitUrl(url); var name, args = []; do { if (!path.length) { //     - name = 'Controllers.Index'; break; } //         name = 'Controllers.' + path.join('.') + '.Index'; if (controllers[name]) break; //  -      name = 'Controllers.' + path.join('.'); if (controllers[name]) break; //    -    args.unshift(path.pop()); } while (true); return { name : name, args : args }; }, splitUrl : function (urlForSplit) { return url .parse(urlForSplit, true) .pathname.split('/') .filter(function (item) { return !!item; }) .map(function (item) { return item.ucfirst(); }); }, }); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कक्षा विस्तार

UPD: टिप्पणियों में मुझे एक विस्तारित राउटर दिखाने के लिए कहा गया था, जब यूआरएल में आपको दो अलग-अलग फाइलों के लिंक निर्दिष्ट करने की आवश्यकता होती है, उदाहरण के लिए, जब रिपॉजिटरी में संशोधन की तुलना करते हैं। लेकिन लिंक पहचानकर्ता द्वारा नहीं होना चाहिए, लेकिन रास्ते से, उदाहरण के लिए, " shock/spirit/init.js/f81e45



"। मैं इस लिंक टेम्पलेट का उपयोग करने का सुझाव देता हूं:

http://example.com/compare/( shock/spirit/init.js/f81e45 )/( tenshi/spirit/src/init.js/d5d218 )



, जिसमें प्रत्येक फ़ाइल कोष्ठक में इंगित किया गया है। लेकिन फ्रेमवर्क टूल्स इसकी अनुमति नहीं देते हैं। इससे कोई फर्क नहीं पड़ता हमारी परियोजना में (फ्रेमवर्क को छुए बिना) हम राउटर बनाते हैं। Regexp वर्ग:

 exports['Router.Regexp'] = function (spirit) { return new Class({ Extends : spirit.load('Router.Regexp', true), prepareRegexp : function (route) { return this.parent(route) .replace(/:P/g, '([0-9a-z._\\/-]+)'); } }); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हमने एक नया संशोधक पेश किया - ": पी"। यह शायद केवल Router.Regexp.replaces ऑब्जेक्ट का विस्तार करने के लिए अधिक सही होगा, लेकिन मैं विधि अधिभार की संभावनाओं को दिखाना चाहता था। ठीक है, अब init.js में एक नया मार्ग जोड़ें:

 spirit.createRouter() .addRoutes( // ... { route : "</compare/(:P)/(:P)>" , contr : 'Man.Route:compare' } );
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और Man.Route में विधि जोड़ें:

  compareAction : function (args) { this.exit('Compare "' + args[0] + '" and "' + args[1] + '"'); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हम लिंक का अनुसरण करते हैं http://example.com/compare/( shock/spirit/init.js/f81e45 )/( tenshi/spirit/src/init.js/d5d218 )



और उत्तर प्राप्त करें:

Compare " shock/spirit/init.js/f81e45 " and " tenshi/spirit/src/init.js/d5d218 "

निष्कर्ष

इसलिए, हमने अपनी परियोजना बनाई, सर्वर को वेब पर प्रदर्शित किया, यह सीखा कि कक्षाओं को कैसे शामिल किया जाए और, पते को छांटा जाए, कार्रवाई के निष्पादन को आवश्यक नियंत्रक को भेजें। निम्नलिखित लेखों में, हम कुछ प्रकार के टेम्पलेट इंजन, और मॉडल के रूप में दृश्य को जोड़ेंगे, जो हमारी वस्तुओं के बारे में जानकारी संग्रहीत करेगा। कुछ लेखों में हम अपने ढांचे पर एक ब्लॉग लिखने की कोशिश करेंगे। रुचि रखते हैं?