🔚 🍀 🦔 PHP मॉड्यूल इंजन विकास ▪️ ⛳️ 🤤

कई अलग-अलग PHP इंजन हैं, जो साधारण से बहुत भारी और भारी हैं, जिसमें लगभग सब कुछ शामिल है।

लेकिन मेरी राय में सबसे अच्छा इंजन एक्स्टेंसिबल है। और ऐसा नहीं है कि यह अपनी क्षमताओं के ढेर के लिए कुछ और टाई करने की पेशकश करता है, लेकिन एक जिसमें इसकी कोई क्षमता नहीं है, लेकिन केवल वही हैं जिन्हें चुना जा सकता है।

छह महीने से कम समय पहले, मैंने सोचा कि इस तरह के इंजन को कैसे बनाया जाए। लिखने के लिए पहली चीज थी बूटलोडर। एक प्रकार का छद्म-मॉड्यूल (उस पर बाद में) जो अन्य मॉड्यूल को लोड करता है।

चलो संरचना पर निर्णय लेते हैं: मान लें कि हमारे पास एक मॉड फ़ोल्डर है जिसमें मॉड्यूल संग्रहीत हैं।
उदाहरण के लिए / mod / staticpages / * । लोडर मानक के अनुसार, मॉड्यूल में कॉन्फ़िगरेशन फ़ाइल, मॉड्यूल का मुख्य वर्ग और वैकल्पिक रूप से जुड़ा हुआ पुस्तकालय होना चाहिए।

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

[Custom] name = "Static Pages"; author = "ShadowPrince"; devname = "staticpages"; version = "0.1";

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

मैनिफ़ेस्ट में एक और सेक्शन जोड़ें:

 [Module] mainclass = "staticpages.php"; mainclassname = "StaticPages";

अब, इस मॉड्यूल को संसाधित करते समय, हम इसकी कक्षा के साथ एक फ़ाइल लोड कर सकते हैं (या इसमें शामिल कर सकते हैं)।
अब एल्गोरिथ्म कुछ इस तरह होगा:
1. सभी फोल्डर / मॉड / पढ़ें।
2. अगर वहाँ है। तो, जारी रखें।
3. हमें मेनक्लास मान मिलता है , इस फाइल को शामिल करें।
4. देवनाम नामक वर्ग का एक उदाहरण बनाएँ। यह वही है जो इस क्षेत्र के लिए है।
परिणामस्वरूप, हमें $ staticpages नाम के साथ StaticPages वर्ग की एक वस्तु मिलती है । ऑब्जेक्ट वैश्विक होगा, इसके साथ अन्य मॉड्यूल की सुविधाजनक बातचीत के लिए।
अब आगे के कोड में हम इस मॉड्यूल की क्षमताओं का उपयोग कर सकते हैं।

लेकिन अब हम एक और समस्या में भाग लेते हैं:
मान लें कि हमारे पास इस तरह का अनुरोध है: " ? Ins = staticpage & page = info ", जो, सिद्धांत रूप में, जानकारी के साथ एक स्थिर पृष्ठ दिखाना चाहिए। लेकिन स्टेटिक पेज मॉड्यूल इस बारे में कैसे सीखता है, जो इसके लिए जिम्मेदार होना चाहिए?
बेशक, आप हैंडलर को क्लास के कंस्ट्रक्टर में रख सकते हैं, जैसे कि अगर ins = staticpage , लेकिन उस समय हम यह सुनिश्चित करने के लिए नहीं जानते हैं कि क्या स्टैटिक पेज के काम करने के लिए जो अन्य मॉड्यूल की आवश्यकता होती है, वे लोड किए गए थे, और सामान्य रूप से - क्या यह इसके लायक है?

इसलिए हमें प्रकट में एक और अनुभाग जोड़ने की आवश्यकता है:

 [Run] run = "template()"

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

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

हमें एक और अवधारणा, साथ ही साथ एक पैरामीटर प्रस्तुत करना होगा, अर्थात्: कतार और आवश्यकता।
कतार, हमारे मामले में, कुछ कार्रवाई करने के लिए मॉड्यूल (जो स्पष्ट है) की कतार है।
और अब - हम स्टेटिक पेज मॉड्यूल के [रन] सेक्शन को संशोधित करते हैं:

 [Run] run = "template()" require = "pex"

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

एक और महत्वपूर्ण बात: हमारे स्टेटिक पेज के संचालन के लिए हार्ड-इंस्टॉल्ड मॉड्यूल की जांच करना, साथ ही साथ उनके संस्करण भी। निम्नलिखित विभाग जोड़ें:

 [Require] data = "core:0.2, template:0.1, mysql:0:1, lang:0.2";

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

लेकिन हमारी "कतारें" बहुत अच्छी तरह से प्रदर्शन को प्रभावित नहीं करती हैं, और डेवलपर्स के लिए सभी मॉड्यूलों को निर्दिष्ट करना कठिन होगा जो इस पर निर्भर करते हैं। इसलिए, मॉड्यूलर तरीकों के निष्पादन के लिए "स्तरों के एक जोड़े" बनाना सबसे उचित होगा।
ये नए विभाग होंगे: पहले, [प्रीव] , पहले से ही [रन] , [बाद], और [फिनिश], वाले तरीकों को निष्पादित किया जाएगा ।

उदाहरण के लिए, pex मॉड्यूल मेनिफेस्ट का हिस्सा लें:

 [Prev] run = "getGroup()"; require = "auth"; [Run] run = "template()"; [After] run = "nodesContainers()"

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

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

 [Include] dirs = "";

बूटलोडर इस विभाग की जांच करेगा और यदि आवश्यक हो, तो फ़ोल्डर्स से सभी फाइलें शामिल करें।

अंत में, index.php में हमारे पास कुछ इस तरह होगा:

 include "core/lib/module/mod.php"; //     include "core/engine.php"; //  -  Engine::loadLibs(); //       (  ) session_start(); //  $engine = new Engine(); //   $engine->enableModules(); //    $engine->modTemplates(); //     ModError::printErrors(); //   (      ,   )

आखिर में हमारे पास क्या है?

मॉड्यूल लोडिंग का लगभग पूर्ण स्वचालन, पूरा सिस्टम मॉड्यूलरिटी। डेटाबेस के साथ काम करना - mysql मॉड्यूल। टेम्पलेट्स के साथ काम करना - टेम्पलेट मॉड्यूल। नेविगेशन बार स्पीडबार मॉड्यूल है। कोई जरूरत नहीं फ़ोल्डर हटाएँ।
सुविधाजनक टेम्पलेट कंटेनरों का उपयोग करना, जैसे <! [Mod = speedbar]> स्पीडबार यहाँ: <! स्पीडबार> <! [/ Mod = speedbar]> , एक मॉड्यूल है - यह काम करता है और अनुभाग प्रदर्शित होता है। कोई मॉड्यूल - अनुभाग बिल्कुल नहीं दिखाया गया है।

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

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

इस पद्धति का वर्तमान मॉडल मेरे पृष्ठ पर देखा जा सकता है (लिंक प्रोफ़ाइल में है), और स्रोत कोड GitHub रिपॉजिटरी में हैं ।

आपके ध्यान के लिए धन्यवाद, अगर किसी को विषय में दिलचस्पी है, तो मैं सिद्धांत से अभ्यास के लिए संक्रमण पर एक विषय लिखूंगा।

PHP मॉड्यूल इंजन विकास

आखिर में हमारे पास क्या है?

More articles: