🎦 🍆 🤝 MODx क्रांति में प्रोसेसर प्रोग्रामिंग प्रतिमान 🤳🏽 🔖 ♾

तुरंत एक आरक्षण करें कि यह लेख तर्क और विचार के लिए भोजन है। मैं पूरी तरह से होलीवर्स की व्यवस्था नहीं करना चाहता और अपने प्रोग्रामिंग के तरीकों को दूसरों पर थोपना चाहता हूं। मैं आपको सिर्फ इसलिए बता रहा हूं, क्योंकि मैं खुद महसूस करता हूं कि मैंने पिछले एक साल में जिन प्रोग्रामिंग तरीकों का इस्तेमाल किया है, वे बहुत बदल गए हैं और पिछले कुछ वर्षों के तरीकों से मौलिक रूप से अलग हैं।

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

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

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

1. कोर / मॉडल / मोडेक्स / प्रोसेसर / में हमारे प्रोसेसर के लिए एक फ़ोल्डर बनाएं, इसे नाम दें, उदाहरण के लिए, संपत्ति /
2. प्रोसेसर फ़ाइल doc / create.php बनाएं (पूर्ण पथ कोर / मॉडल / मॉडेक्स / प्रोसेसर / संपत्ति / डॉक्टर / create.php होगा)

3. हम इसमें वह कोड लिखते हैं जिसकी हमें आवश्यकता होती है

<? if(!$scriptProperties['pagetitle']){ return $modx->error->failure('    '); } if(!isset($scriptProperties['parent'])){ return $modx->error->failure('     '); } $doc = $modx->newObject('modResource', scriptProperties); if(!$doc->save()){ return $modx->error->failure('   '); } return $modx->error->success('  ', $doc->toArray());

4. और अब हमें जिस जगह की आवश्यकता है, हम इस प्रोसेसर को कॉल करेंगे

 $response = $modx->runProcessor('assets.doc.create', array( 'parent' => 0, 'pagetitle' => ' ' )); if($response->isError()){ print " ". $response->getMessage(); } else{ $object = $response->getObject(); print "    ID {$object['id']}"; } /*$modx->runProcessor -   MODx.   .php     ,       create.php  -  .      assets.doc.create   ,       assets/doc/         core/model/modx/processors/       ,       $modx->runProcessor($path, $properties, array( processors_path => self::$processorsPath));    $properties -  ,          scriptProperties.       .       $modx,            . */

यह एक निजी उदाहरण है और मैं जो कहना चाहता था, उसके बारे में भी नहीं बताता।
एक बार में कई नेस्टेड प्रोसेसर का उपयोग करते समय इस पद्धति का उपयोग करने की सुंदरता अधिक प्रकट होती है।

यहां हम उस प्रोसेसर को कॉल करेंगे जिसमें अन्य प्रोसेसर कहलाते हैं (तथाकथित प्रोसेसर का कोड दिया गया है)।

 <? $user = false; $doc = false; //    $response = $modx->runProcessor('security/user/create', $scriptProcessor); //  ,      if($response->isError()){ return $modx->error->failure($response->getMessage()); } else{ //    $user = $response->getObject(); } //   ,      $response = $modx->runProcessor('assets.doc.create', array( 'parent' => 0, 'pagetitle' => ' ' )); // -,  ,      if($response->isError()){ return $modx->error->failure($response->getMessage()); } else{ //    $doc = $response->getObject(); } //   ,   return array( 'success' => true, 'message' => '', 'object' => array( 'user' => $user, 'doc' => $doc, ) ); /*  ,        $modx->error->success(failure),    .         ,    $response->getObject()      ,     .  $modx->error->success('', $object);    .    $modx->error->success    ,               ,          .       ,    security/user/create   $user->toArray(),   $user,       $user,   .           modUser  ->toArray()      'object',    ,       $response->getObject()->get('id'); */

इस प्रकार, आउटपुट पर हमें एक स्पष्ट परिणाम मिलता है, या $ प्रतिक्रिया-> isrror (), या नहीं।
उसी समय, हम इन प्रोसेसर के घोंसले के शिकार की डिग्री के बारे में नहीं सोचते हैं, चाहे प्रोसेसर के नेस्टिंग के कितने स्तर हों, निष्पादन के उचित संगठन के साथ, कोई फर्क नहीं पड़ता कि किस स्तर पर नेस्टिंग में कोई त्रुटि होती है, हम इसके बारे में जानेंगे और पाठ संदेश प्रदर्शित करेंगे, क्योंकि वापसी $ modx- > त्रुटि-> विफलता ($ प्रतिक्रिया-> getMessage ()); हर बार अगले एम्बेडेड प्रोसेसर का संदेश लौटाएगा।

यह ध्यान दिया जाना चाहिए कि MODx का पूरा व्यवस्थापक भाग प्रोसेसर पर लिखा है (/ कोर / मॉडल / मॉडेक्स / प्रोसेसर / फ़ोल्डर देखें) और यदि प्रोसेसर का सही उपयोग किया जाता है, तो कई तृतीय-पक्ष पैकेजों की आवश्यकता नहीं हो सकती है।
$ Modx-> runSnippet ('सुरक्षा / लॉगिन', $ scriptProcessor) से अधिक सरल क्या हो सकता है?
MODx सब कुछ आवश्यक करेगा और इस मामले में यह सभी मामलों के लिए निर्धारित त्रुटि संदेशों में से एक को लौटाएगा। इन प्रोसेसरों में, और एक्सेस अधिकारों के लिए जाँच करता है, और सभी प्रकार के सिस्टम चर, और अन्य संबंधित प्रोसेसर को कॉल करता है। सामान्य तौर पर, आपको जो कुछ भी चाहिए ...

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

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

MODx क्रांति में प्रोसेसर प्रोग्रामिंग प्रतिमान

More articles: