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



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

अशुद्धता क्या है?

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

 <? php
 मिक्स टाइमिबल {
     निजी $ timeStarted;
     निजी $ समय;
     सार्वजनिक समारोह शुरू () {$ timeStarted = time ();  }
     सार्वजनिक समारोह रोक () {$ timeStnect = time ();  }
     सार्वजनिक समारोह getElapsed () {$ $ लौटा दिया - $ timeStarted}
 }

 मिक्स डंपेबल {
     सार्वजनिक समारोह डंप () {var_dump ($ यह);  }
 }

 वर्ग MyClass मिश्रण करने योग्य, Dumpable {
     सार्वजनिक समारोह हैलो () {}
 }

 $ a = नया MyClass ();
 $ a-> प्रारंभ ();
 नींद (250);
 $ a-> स्टॉप ();
 इको $ a-> getElapsed ();
 $ a-> डंप ();
 ?>

क्या विचार स्पष्ट है? अशुद्धताएं केवल कक्षा में उनकी कार्यक्षमता को जोड़ती हैं, जैसे कि कक्षा को उन सभी से तुरंत विरासत में मिला था। हालांकि, वे उस वर्ग के सदस्यों में हेरफेर कर सकते हैं जिसमें वे मिश्रित हैं। यह PHP में लागू होने वाली कार्यक्षमता का प्रकार है।

चलो अपने आप को कार्य निर्धारित करते हैं।

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

हम एक रजिस्ट्री डिजाइन कर रहे हैं।

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



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

class Registry { private static $registeredMixins = array(); public static function register($className, $mixinClassName) { $mixinClassNames = func_get_args(); unset($mixinClassNames[0]); foreach ($mixinClassNames as $mixinClassName) { self::$registeredMixins[$className][] = $mixinClassName; } self::$classNameToMixinCache = array(); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



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

कैशिंग फ़ंक्शन के लिए, हमें एक फ़ंक्शन की आवश्यकता होती है जो इस वर्ग के पूर्वजों की सूची प्राप्त करता है:

  private static $classNameToMixinCache = array(); private static function getAncestors($className) { $classes = array($className); while (($className = get_parent_class($className)) !== false) { $classes[] = $className; } return $classes; } private static function precacheMixinListForClass($className) { if (isset(self::$classNameToMixinCache[$className])) { return; } $ancestors = self::getAncestors($className); $result = array(); foreach ($ancestors as $ancestor) { if (isset(self::$registeredMixins[$ancestor])) { $result = array_merge($result, self::$registeredMixins[$ancestor]); } } self::$classNameToMixinCache[$className] = array_unique($result); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



अब, अगर हमें किसी दिए गए वर्ग के लिए अशुद्धियों की सूची प्राप्त करने की आवश्यकता है, तो हम इस फ़ंक्शन का उपयोग कर सकते हैं:

  public static function getMixinsFor($className) { self::precacheMixinListForClass($className); return self::$classNameToMixinCache[$className]; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

चूंकि प्रवेश कक्षा का सार है, हम कुछ इस तरह करते हैं:

  private static $methodLookupCache = array(); public static function getMixinNameByMethodName($className, $methodName) { if (isset(self::$methodLookupCache[$className][$methodName])) { return self::$methodLookupCache[$className][$methodName]; } self::precacheMixinListForClass($className); foreach (self::$classNameToMixinCache[$className] as $mixin) { if (method_exists($mixin, $methodName)) { self::$methodLookupCache[$className][$methodName] = $mixin; return $mixin; } } throw new MemberNotFoundException("$className has no mixed method $methodName()!"); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

संपत्तियों के लिए वास्तव में एक ही विकल्प प्राप्त होता है। मेरा सुझाव है कि आप इसे स्वयं लिखें।

वह सब है। हमने रजिस्ट्री लागू कर दी है। हम अशुद्धता वर्ग की प्रोग्रामिंग के लिए आगे बढ़ते हैं।

हम एक प्रवेश कार्यक्रम बनाते हैं।

तो, एक प्रशंसा। क्या अशुद्धता? प्रवेश एक साधारण वर्ग है। वह सिर्फ यह जानता है कि दूसरे वर्ग के क्षेत्रों के साथ कैसे काम किया जाए। और कंस्ट्रक्टर में इसे पास करने के लिए इस अन्य वर्ग का एक उदाहरण तर्कसंगत होगा।

 class Base { protected $_owningClassInstance; protected $_owningClassName; public function __construct($owningClassInstance) { $this->_owningClassInstance = $owningClassInstance; $this->_owningClassName = get_class($owningClassInstance); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



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

  protected $_owningPropertyReflectionCache; protected $_owningMethodReflectionCache; protected function getProtected($name) { if (! isset($this->_owningPropertyReflectionCache[$name])) { $property = new \ReflectionProperty($this->_owningClassName, $name); $property->setAccessible(true); $this->_owningPropertyReflectionCache[$name] = $property; } return $this->_owningPropertyReflectionCache[$name]->getValue($this->_owningClassInstance); } protected function setProtected($name, $value) { if (! isset($this->_owningPropertyReflectionCache[$name])) { $property = new \ReflectionProperty($this->_owningClassName, $name); $property->setAccessible(true); $this->_owningPropertyReflectionCache[$name] = $property; } $this->_owningPropertyReflectionCache[$name]->setValue($this->_owningClassInstance, $value); } protected function invokeProtected($name, $parameters) { $method = new \ReflectionMethod($this->_owningClassName, $name); $method->setAccessible(true); $parameters = func_get_args(); unset($parameters[0]); $method->invokeArgs($this->_owningClassInstance, $parameters); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

किसी ने पहले से ही देखा होगा कि method_exists () और property_exists () फ़ंक्शन जो हमने रजिस्ट्री क्लास में उपयोग किए थे, अशुद्धियों के लिए दिए गए नाम के साथ छिपे हुए और संरक्षित कार्यों को सार्वजनिक लोगों के साथ किया था। यह इस तथ्य की ओर जाता है कि एग्रीगेटर वर्ग फ़ंक्शन को उसी नाम से कॉल करने का "प्रयास" करने में सक्षम होगा यदि इसे छिपे या संरक्षित के रूप में परिभाषित किया गया है। परिणामस्वरूप, हम अभी भी त्रुटि प्राप्त करते हैं, लेकिन मैं इसे स्पष्ट रूप से करना पसंद करता हूं:

  public function __call($name, array $arguments) { throw new MemberNotFoundException( "Method $name is not defined or is not accessible in mixin \"" . get_class() . "\""); } public function __get($name) { throw new MemberNotFoundException( "Property $name is not defined or is not accessible in mixin \"" . get_class() . "\""); } public function __set($name, $value) { throw new MemberNotFoundException( "Property $name is not defined or is not accessible in mixin \"" . get_class() . "\""); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक छोटे से काम के रूप में, हमारे रजिस्ट्री वर्ग के इस तरह के अयोग्य व्यवहार को ठीक करने का प्रयास करें। इसके अलावा, यह एक नाम के साथ सार्वजनिक अशुद्धता विधि को लागू करने में असमर्थता का कारण बनेगा जो पहले से छिपा हुआ है या दूसरे में संरक्षित है।



उम। वह सब है। मिश्रण खाने के लिए तैयार है। अंतिम चरण बना हुआ है - अशुद्धियों के मिश्रण के लिए मंच का कार्यान्वयन - एग्रीगेटर कक्षाएं। अब हम यही करेंगे।

हम एक एग्रीगेटर क्लास लिखते हैं।

एक एग्रीगेटर वर्ग क्या कर सकता है? वह जानता है कि किस तरह से अशुद्धियों की कक्षाओं को संग्रहीत करना और उनके तरीकों को कॉल करना है। खैर, गुणों का संदर्भ लें। हम PHP के "जादू" तरीकों का उपयोग करके इस व्यवहार को लागू करेंगे।

 class Aggregator { protected $_mixins; protected $_className; public function __construct($aggregatorClassInstance = false) { $this->_className = $aggregatorClassInstance ? get_class($aggregatorClassInstance) : get_class($this); $mixinNames = Registry::getMixinsFor($this->_className); foreach ($mixinNames as $mixinName) { $this->_mixins[$mixinName] = new $mixinName($aggregatorClassInstance ? $aggregatorClassInstance : $this); } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

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



यदि ऊपर दिया गया स्पष्टीकरण आपको बहुत जटिल लगता है - तो कोई बात नहीं। थोड़ा कम सरकना, उदाहरण हैं। देखें कि इनहेरिटेंस उदाहरण संरचना उदाहरण से कैसे भिन्न होता है और वे कैसे काम करते हैं।



हमें "जादू के तरीकों" का एहसास है।

  public function __call($name, array $arguments) { return call_user_func_array(array($this->_mixins[Registry::getMixinNameByMethodName($this->_className, $name)], $name), $arguments); } public function __get($name) { return $this->_mixins[Registry::getMixinNameByPropertyName($this->_className, $name)]->$name; } public function __set($name, $value) { $this->_mixins[Registry::getMixinNameByPropertyName($this->_className, $name)]->$name = $value; } public function __isset($name) { return isset($this->_mixins[Registry::getMixinNameByPropertyName($this->_className, $name)]->$name); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रत्येक मैजिक मेथड जानकारी के लिए रजिस्ट्री में बदल जाता है। सब कुछ सरल है।



अपवाद वर्ग जिसका हमने उपयोग किया वह इस प्रकार है:

 class MemberNotFoundException extends \Exception {}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आइए कुछ उदाहरण देखें।

विरासत के साथ पारंपरिक योजना के लिए पहली:

 class MixinAggregatorSample extends Mixins\Aggregator { } class MixinHello extends Mixins\Base { protected $inaccessible; public $text = "I am a text!\r\n"; public function hello() { echo ("Hello from mixin!\r\n"); } } Mixins\Registry::register("MixinAggregatorSample", "MixinHello"); $a = new MixinAggregatorSample(); $a->hello(); //Accesing mixed methid echo ($a->text); //Accessing mixed property $a->text = "I am also a text!\r\n"; //Setting mixed property //$a->inaccessible = 'Error here'; //Throws exception //$a->inaccessible2 = 'Error here'; //Throws yet another exception (Homework: explain, why) echo ($a->text); var_dump(isset($a->text));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अब समावेश सर्किट पर एक नज़र डालें:

 class MixinAggregatorSample { protected $_aggregator; public function __construct() { $this->_aggregator = new Mixins\Aggregator($this); } public function __call($name, $arguments) { return $this->_aggregator->__call($name, $arguments); } } class MixinHello extends Mixins\Base { public function hello() { echo ("Hellp from mixin!"); } } Mixins\Registry::register("MixinAggregatorSample", "MixinHello"); $a = new MixinAggregatorSample(); $a->hello();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

गति

मैंने परिणामी लाइब्रेरी की गति के कुछ माप किए। माप बहुत अनुमानित हैं, एक खुले आईडीई, Winamp और जो कुछ भी माना जाता है, उसके साथ एक घरेलू कंप्यूटर पर किया जाता है

 समय मूल: 0.57831501960754
 समय के अनुसार: 1.5227220058441
 समय मिश्रित: 7.5425450801849
 समय प्रतिबिंब: 12.221807956696

• मूल निवासी - PHP में सीधे वर्ग विधि को कॉल करने का समय
• Byname - $ myClass -> $ methodName नाम के माध्यम से एक क्लास पद्धति को कॉल करने का समय
• मिश्रित - मिश्रित विधि कॉल समय
• परावर्तन - एक मिश्रित पद्धति को कॉल करने का समय जो प्रतिबिंब के माध्यम से एक वर्ग की संपत्ति को बदलता है। यानी = मिश्रित + प्रतिबिंब।
• 800,000 कॉल के लिए सेकंड में समय दिया गया है।

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



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

उपसंहार

इस लेख के संबंध में आपकी आलोचना सुनकर मुझे प्रसन्नता हुई। मुझे विशेष रूप से दिलचस्पी है कि क्या मैं सभी पाठकों के लिए सामग्री को समझने में कामयाब रहा।



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



यदि PHP में अशुद्धियों का विषय आपकी रुचि है, तो मेरा सुझाव है कि आप भी Google।