🎠 🏻 🔗 DIY मिनी ढांचा 👨‍🎤 🌘 🙆🏿

हाल ही में, सिलेक्स मिनी-फ्रेमवर्क के बारे में पढ़ने के बाद, मैंने सोचा: इसके बारे में इतना जटिल क्या है? मैंने कुछ ऐसा ही लिखने की कोशिश की और यह बहुत आसान हो गया।

ऐसे मिनी-फ्रेम आमतौर पर mod_rewrite के लिए निम्नलिखित नियमों पर आधारित होते हैं:

Copy Source | Copy HTML < IfModule mod_rewrite . c > RewriteEngine On RewriteBase / RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule ^(.*)$ index.php [QSA,L] </ IfModule >
Copy Source | Copy HTML < IfModule mod_rewrite . c > RewriteEngine On RewriteBase / RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule ^(.*)$ index.php [QSA,L] </ IfModule >
Copy Source | Copy HTML < IfModule mod_rewrite . c > RewriteEngine On RewriteBase / RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule ^(.*)$ index.php [QSA,L] </ IfModule >
Copy Source | Copy HTML < IfModule mod_rewrite . c > RewriteEngine On RewriteBase / RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule ^(.*)$ index.php [QSA,L] </ IfModule >
Copy Source | Copy HTML < IfModule mod_rewrite . c > RewriteEngine On RewriteBase / RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule ^(.*)$ index.php [QSA,L] </ IfModule >
Copy Source | Copy HTML < IfModule mod_rewrite . c > RewriteEngine On RewriteBase / RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule ^(.*)$ index.php [QSA,L] </ IfModule >
Copy Source | Copy HTML < IfModule mod_rewrite . c > RewriteEngine On RewriteBase / RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule ^(.*)$ index.php [QSA,L] </ IfModule >
Copy Source | Copy HTML < IfModule mod_rewrite . c > RewriteEngine On RewriteBase / RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule ^(.*)$ index.php [QSA,L] </ IfModule >

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

Copy Source | Copy HTML
फ़ंक्शन अनुरोध ( $ पथ , $ कॉलबैक )
{
अगर ( $ पथ == $ _SERVER [ 'REQUEST_URI' ]) कॉल call_user_func ( $ कॉलबैक );
}

जब कॉल किया जाता है, तो फ़ंक्शन उस पते की जांच करता है जिसे उपयोगकर्ता ने एक्सेस किया था, और यदि यह फ़ंक्शन के पास से मेल खाता है, तो यह कॉलबैक कहता है। यह पहले से ही बुनियादी कार्यक्षमता माना जा सकता है। हालांकि, कोई एक आवश्यक चीज नहीं है - एक पते से चर निकालना। इसके अलावा, example.com/something और example.com/something पतों को फ़ंक्शन द्वारा अलग माना जाएगा। आप पते को पार्स करके और array_filter का उपयोग करके इसे हल कर सकते हैं:

Copy Source | Copy HTML
समारोह array_filter_callback_no_empty_str ( $ मूल्य )
{
$ मूल्य लौटाएँ ! = '' ;
}
फ़ंक्शन अनुरोध ( $ पथ , $ कॉलबैक )
{
// कॉलबैक पास करने के लिए चर का अनुरोध करें
$ args = array ();
// उस पते को तोड़ें जिसे उपयोगकर्ता ने (URI) भागों में एक्सेस किया था
$ uri = विस्फोट ( '/' , $ _SERVER [ 'REQUEST_URI' ]);
// क्वेरी पथ के साथ ऐसा ही करें
$ पथ = विस्फोट ( '/' , $ पथ );
// दोनों सरणियों के खाली हिस्सों को हटा दें
$ uri = array_values (array_filter ( $ uri , array_filter_callback_no_empty_str));
$ पथ = array_values (array_filter ( $ पथ , array_filter_callback_no_empty_str));
// यदि यूआरआई और पथ में भागों की संख्या अलग-अलग है, तो बाहर निकलें
अगर (गणना ( $ uri )! = गिनती ( $ पथ ))
झूठे लौटना ;
// हम अनुरोध पथ के सभी भागों से गुजरते हैं
के लिए ( $ i = 0 ; $ i <गिनती ( $ पथ ); $ i ++)
{
// जांचें कि क्या पथ का दिया गया हिस्सा एक चर है
// चर पथ ब्रेसिज़ में संलग्न हैं, जो नियमित अभिव्यक्ति की जांच करता है
अगर (preg_match ( '| ^ \ {(। *) \} $ |' , $ पाथ [ $ i ], $ माचिस )
{
// यदि है, तो इस चर को सरणी में जोड़ें
$ args [ $ मैच [ 1 ]] = $ uri [ $ i ];
}
अन्यथा
{
// यदि अनुरोध का हिस्सा परिवर्तनशील नहीं है, तो बस अनुरोध के साथ URI की तुलना करें
// यदि वे मेल नहीं खाते हैं, तो बाहर निकलें
अगर ( $ uri [ $ i ]! = $ path [ $ i ])
झूठे लौटना ;
}
}
// सभी जांचों के बाद, हम कॉलबैक कहते हैं, इसे अनुरोध चर के साथ एक सरणी दे रहे हैं
वापसी call_user_func_array ( $ कॉलबैक , $ args );
}

अब आप इस तरह कोड लिख सकते हैं:

Copy Source | Copy HTML
समारोह नमस्कार ( $ कौन )
{
प्रिंट "हैलो, $ कौन" ;
}
अनुरोध ( '/ हैलो / {कौन}' , हैलो);

अब, Silex को देखें और देखें कि हम क्या याद कर रहे हैं। सबसे पहले, ये दावे (नियमित अभिव्यक्ति के खिलाफ पथ चर की जाँच), कॉल विधि (GET, POST, PUT, आदि) और एक ऑब्जेक्ट-ओरिएंटेड मॉडल की जाँच कर रहे हैं। पहले दो को जोड़ने के लिए काफी सरल हैं, आपको बस कुछ जोड़े जोड़ने की जरूरत है:

Copy Source | Copy HTML
फ़ंक्शन अनुरोध ( $ पद्धति , $ पथ , $ कॉलबैक , $ मुखर = सरणी ())
{
// सर्वर तक पहुंचने की विधि की जाँच करें।
// यदि अनुरोध में एक विशिष्ट विधि निर्दिष्ट की गई है और यह उस से मेल नहीं खाती है जिसका उपयोग किया गया था, तो बाहर निकलें
if ( $ पद्धति ! = '' && strtolower ( $ _SERVER [ 'REQUEST_METHOD' ])! = $ पद्धति )
झूठे लौटना ;
<...>
// अब जाँच करें कि पथ का दिया गया भाग एक चर है या नहीं
अगर (preg_match ( '| ^ \ {(। *) \} $ |' , $ पाथ [$ i], $ माचिस )
{
// यदि यह है, तो देखें कि क्या इसका परीक्षण करने के लिए एक नियमित अभिव्यक्ति है,
// और अगर वहाँ है, तो हम यूआरआई के संबंधित भाग के अनुपालन की जांच करते हैं
अगर ( isset ( $ asserts [ $ match [ 1 ]])) || preg_match ( $ asserts [ $ match [ 1 ]], $ uri [$ i]))
{
// यदि सब कुछ सही है, तो इस वैरिएबल को इसके मान के साथ सरणी में जोड़ें
$ args [ $ मैच [ 1 ]] = $ uri [$ i];
}
अन्यथा
{
// यदि मान नियमित अभिव्यक्ति से मेल नहीं खाता है, तो बाहर निकलें
झूठे लौटना ;
}
}
<...>
}

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

Copy Source | Copy HTML
कक्षा अनुरोध
{
सार्वजनिक $ विधि ; // अनुरोध विधि (GET, POST, PUT, आदि)
सार्वजनिक $ पथ ; // अनुरोध पथ
सार्वजनिक $ कॉलबैक ; // कॉलबैक
सार्वजनिक $ asserts = array (); // पथ चर की जाँच के लिए नियमित अभिव्यक्ति
// क्लास कंस्ट्रक्टर
सार्वजनिक कार्य __construct ( $ पद्धति , $ पथ , $ कॉलबैक )
{
$ यह -> विधि = स्ट्रेटोलॉवर ( $ विधि );
$ यह -> पथ = $ पथ ;
$ यह -> कॉलबैक = $ कॉलबैक ;
}
// नाम के पथ चर का परीक्षण करने के लिए regex जोड़ें
सार्वजनिक समारोह मुखर ( $ नाम , $ re )
{
$ यह -> जोर देता है [ $ नाम ] = $ फिर से ;
// कक्षा का वर्तमान उदाहरण लौटाएं
// यह समान कोड लिखना संभव बनाता है: $ reg-> मुखर ('आईडी', '| ^ \ d + $ |') -> रन ();
यह $ वापस करो ;
}
// अनुरोध प्रसंस्करण समारोह
सार्वजनिक समारोह चलाना ()
{
<...>
}
}

दो बिंदुओं को छोड़कर, सब कुछ सुंदर लगता है। पहला बिंदु विशुद्ध रूप से सौंदर्यवादी है - अब एक अनुरोध को संसाधित करने के लिए आपको कोड की दो लाइनें लिखने की आवश्यकता है:

Copy Source | Copy HTML
$ req = नया अनुरोध ( '/ user / {id}' , UserProfile);
$ req -> assert ( '| ^ \ d + $ |' ) -> run ();

लेकिन सौभाग्य से, PHP हमें कक्षाओं और कार्यों के लिए समान नामों का उपयोग करने की अनुमति देता है, इसलिए हम एक आवरण फ़ंक्शन लिखेंगे जो कक्षा का एक उदाहरण बनाएगा और वापस लौटाएगा:

Copy Source | Copy HTML
फ़ंक्शन अनुरोध ( $ पद्धति , $ पथ , $ कॉलबैक )
{
नया अनुरोध वापस करें ( $ पद्धति , $ पथ , $ कॉलबैक );
}

अब आप सब कुछ कॉम्पैक्ट और आसानी से लिख सकते हैं:

Copy Source | Copy HTML
निवेदन ( '/ user / {id}' , UserProfile) -> अभिकथन ( '| ^ \ d + $ |' ) -> run ();

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

Copy Source | Copy HTML
कक्षा आवेदन
{
सार्वजनिक $ अनुरोध = सरणी ();
/// ---
// सिंग्लटन लागू करें
संरक्षित स्थिर $ उदाहरण ;
निजी समारोह __construct ()
{
}
निजी समारोह __clone ()
{
}
सार्वजनिक स्थिर फ़ंक्शन getInstance ()
{
अगर (is_object (स्वयं :: $ उदाहरण ))
{
आत्म :: $ उदाहरण = नया आत्म;
}
वापसी स्व :: $ उदाहरण ;
}
सार्वजनिक स्थिर फ़ंक्शन init ()
{
आत्म :: getInstance ();
}
/// ---
// आंतरिक फ़ंक्शन सभी अनुरोधों को संभालने के लिए
निजी समारोह i_run ()
{
foreach ( यह $ -> अनुरोध और $ अनुरोध के रूप में )
{
$ किया = $ अनुरोध -> चलाने ( $ params );
अगर ( $ किया गया ) सही लौटा ;
}
झूठे लौटना ;
}
// बाहरी स्थिर आवरण कार्य i_run पर
// सौंदर्यशास्त्र के लिए विशेष रूप से आवश्यक: एप्लिकेशन :: रन () अनुप्रयोग की तुलना में सुंदर दिखता है :: getInstance () -> रन ()
सार्वजनिक स्थैतिक समारोह रन ()
{
वापसी आवेदन :: getInstance () -> i_run ();
}
}

अनुरोध वर्ग को भी थोड़ा बदलें:

Copy Source | Copy HTML
कक्षा अनुरोध
{
<...>
// क्लास कंस्ट्रक्टर
सार्वजनिक कार्य __construct ( $ पद्धति , $ पथ , $ कॉलबैक )
{
$ यह -> विधि = स्ट्रेटोलॉवर ( $ विधि );
$ यह -> पथ = $ पथ ;
$ यह -> कॉलबैक = $ कॉलबैक ;
// आवेदन के लिए कतार में इस अनुरोध को जोड़ें
आवेदन :: getInstance () -> अनुरोध [] = $ यह ;
}
<...>
सार्वजनिक समारोह चलाना ()
{
<...>
// सभी जांचों के बाद, हम कॉलबैक कहते हैं, इसे अनुरोध चर के साथ एक सरणी दे रहे हैं
$ परिणाम = call_user_func_array ( $ यह -> कॉलबैक, $ यह -> आर्ग्स);
// यदि कॉलबैक ने बूलियन मान लौटाया, तो उसे वापस कर दें
अगर (is_bool ( $ परिणाम ))
$ परिणाम लौटाओ ;
// अन्यथा, सही लौटें
अन्यथा
सच लौटना ;
}
}

एक पथ को संसाधित करने के लिए कई अनुरोधों का उपयोग करने में सक्षम होने के लिए उत्तरार्द्ध आवश्यक है। यदि कॉलबैक गलत होता है, तो निम्नलिखित अनुरोध संसाधित किए जाएंगे, अन्यथा सब कुछ समाप्त हो जाएगा।
सामान्य तौर पर, हमारे मिनी-फ्रेमवर्क का उपयोग बहुत सुंदर और सरल लगता है:

Copy Source | Copy HTML
नया आवेदन ();
निवेदन ( '/ user / {id}' , UserProfile) -> अभिकथन ( '| ^ \ d + $ |' ) -> run ();
आवेदन :: रन ();

हालाँकि, आप आगे भी चीजों को सरल बना सकते हैं। PHP सेटिंग्स में, दो बेहतरीन विकल्प हैं: auto_prepend_file और auto_append_file, जो आपको मुख्य स्क्रिप्ट निष्पादित करने से पहले और बाद में PHP स्क्रिप्ट्स को प्री-स्क्रिप्टेड कनेक्ट करने की अनुमति देते हैं। हम रूपरेखा को एक अलग फ़ाइल में रख सकते हैं और इन कार्यों का उपयोग करके इसे संलग्न कर सकते हैं। पहले कनेक्शन पर, हम कक्षाओं की घोषणा करते हैं और एप्लिकेशन ऑब्जेक्ट बनाते हैं, और दूसरे पर, हम एप्लिकेशन :: रन () कहते हैं। आप यह निर्धारित कर सकते हैं कि स्क्रिप्ट पहली बार चल रही है या नहीं, यह जाँच कर कि क्या एप्लिकेशन क्लास या रिक्वेस्ट क्लास मौजूद है:

Copy Source | Copy HTML
यदि (class_exists ( 'Application' ))
{
// यदि अनुप्रयोग वर्ग अभी तक घोषित नहीं किया गया है, तो स्क्रिप्ट पहली बार चलती है
कक्षा अनुरोध
{
<...>
}
फ़ंक्शन अनुरोध ( $ पद्धति , $ पथ , $ कॉलबैक )
{
<...>
}
कक्षा आवेदन
{
<...>
}
// प्रारंभिक आवेदन,
आवेदन :: init ();
}
अन्यथा
{
// स्क्रिप्ट पहली बार नहीं चल रही है
आवेदन :: रन ();
}

इस प्रकार, हमें दो "अतिरिक्त" लाइनों से छुटकारा मिला।

इस तरह से आप कम या ज्यादा कार्यात्मक मिनी-फ्रेमवर्क लिख सकते हैं। यह Silex तक नहीं पहुंचता है, लेकिन इसका उपयोग करना काफी संभव है। पूर्ण स्रोत कोड (थोड़ा संशोधित) और उपयोग का एक उदाहरण http://fw.nizarium.com/ पर है , जो एक ही मिनी-फ्रेमवर्क पर काम करता है।
कृपया इसे कुछ गंभीर न समझें। यह सिर्फ एक उदाहरण है, मूल रूप से अपने लिए शुद्ध रूप से लिखा गया है। अगर इसमें कोई त्रुटि है, तो मैं उन्हें ठीक करने के लिए तैयार हूं।

DIY मिनी ढांचा

More articles: