Php 5.4 में लक्षण। पार्स कार्यान्वयन विवरण

सबसे हाल ही में , पहला बीटा php 5.4 जारी किया गया था , और जब मैं विषय लिख रहा था , दूसरा समय में आ गया । 5.4 में नवाचारों में से एक लक्षण है। मैं सभी विवरणों को समझने का प्रस्ताव करता हूं कि php में क्या लक्षण हैं।

विकिपीडिया पर नहीं देखने के लिए एक सरल विशेषता उदाहरण:

//  trait Pprint { public function whoAmI() { return get_class($this) . ': ' . (string) $this; } } class Human { use Pprint; // ,   use protected $_name = 'unknown'; public function __construct($name) { $this->_name = $name; } public function __toString() { return (string) $this->_name; } } $a = new Human('Nikita'); echo $a->whoAmI(), PHP_EOL; //=> Human: Nikita 

जैसा कि आप देख सकते हैं, Pprint type से व्यवहार Human वर्ग में जोड़ा गया है।

लेकिन हर चीज का अपना विवरण होता है।

वाक्य-विन्यास

सामान्य तौर पर, सब कुछ सरल है। असीमित संख्या में लक्षण एक वर्ग में एक या अधिक use माध्यम से वर्ग परिभाषा से जुड़े हो सकते हैं। use को कक्षा में कहीं भी निर्दिष्ट किया जा सकता है।

इसके अतिरिक्त, use बाद ब्लॉक ( {...} ) में use आप कर सकते हैं:

• टाइप करने के लिए उपनाम असाइन करें ( Trait::method as myMethod - Trait से method अतिरिक्त रूप से उपलब्ध होगी, जैसे myMethod );
• एक प्रकार की विधि के ओवरलैप को निर्दिष्ट करें, दूसरे की विधि, यदि उनका एक ही नाम है ( TraitA::method insteadof TraitB इसके बजाय TraitA::method insteadof TraitB - TraitA विधि का उपयोग उसी नाम की TraitB विधि के बजाय किया जाएगा);
• किसी विधि से स्थैतिक तक पहुँच बढ़ाने या घटाने के लिए, विधि को स्थैतिक में परिवर्तित करने के अपवाद के साथ ( Trait::publicMethod as protected ), आप तुरंत इसका नाम बदल सकते हैं ( Trait::publicMethod as protected _myProtectedMethod )।

प्रकार खुद को trait रूप में लिखा जाता trait और use कीवर्ड में निर्दिष्ट करके अन्य प्रकार शामिल कर सकते हैं। वाक्यविन्यास और क्षमताएं एक वर्ग में use समान हैं।

अधिक जटिल उदाहरण:

 trait Pprint { public function whoAmI() { return get_class($this) . ': ' . (string) $this; } } trait Namer { //     use Pprint; public function getMyName() { return $this->whoAmI(); } public function getMyLastName() { return 'Unknown =('; } public function getMyNickname() { return preg_replace('/[^az]+/i', '_', strtolower($this->getMyName())); } } trait SuperNamer { public function getMyLastName() { return 'Ask me'; } } class Human { use SuperNamer; use Namer { SuperNamer::getMyLastName insteadof Namer; Namer::getMyNickname as protected _getMyLogin; } protected $_name = 'unknown'; public function __construct($name) { $this->_name = $name; } public function __toString() { return (string) $this->_name; } public function getLogin() { return $this->_getMyLogin(); } } $a = new Human('Nikita'); echo join(', ', get_class_methods($a)), PHP_EOL; //__construct, __toString, getLogin, getMyLastName, //getMyName, getMyNickname, whoAmI echo $a->getMyName(), PHP_EOL; //Human: Nikita echo $a->getMyLastName(), PHP_EOL; //Ask me echo $a->getLogin(), PHP_EOL; //human_nikita echo $a->getMyNickname(), PHP_EOL; //human_nikita 

दो बिंदुओं पर ध्यान देना जरूरी है। सबसे पहले, use बाद ब्लॉक उस प्रकार से संबंधित लगता है जिसके पास इसका वर्णन किया गया है, लेकिन यह नहीं है। ब्लॉक के नियम वैश्विक हैं और इन्हें कहीं भी घोषित किया जा सकता है।

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

 // use SuperNamer, Namer, Singleton, SomeOther { SuperNamer::getMyLastName insteadof Namer; SomeOther::getSomething as private; } //  use Namer; use Singleton; use SuperNamer { SuperNamer::getMyLastName insteadof Namer; } use SomeOther { SomeOther::getSomething as private; } 

दूसरे, तरीकों की सूची पर ध्यान दें, getMyNickname सूची में बनी हुई है, और _getMyLogin कम पहुंच के साथ सिर्फ इसका उपनाम है। आप मूल विधि को पूरी तरह से बाहर कर सकते हैं, लेकिन बाद में जादू अनुभाग में अधिक।

लक्षण प्रारंभिक रूप से कक्षाओं की तरह गतिशील होते हैं। तीव्र इच्छा के साथ, आप इसे लिख सकते हैं:

 if ($isWin) { trait A { /* … */} } else { trait A { /* … */} } 

गुण गुण

इससे पहले, मैंने विधियों पर काम किया था, लेकिन इस प्रकार में वे गुण शामिल हो सकते हैं जिन्हें कक्षा में जोड़ा जाएगा। इस संबंध में, php में "लक्षण" मिक्सिन की तरह अधिक हैं।

 trait WithId { protected $_id = null; public function getId() { return $this->_id; } public function setId($id) { $this->_id = $id; } } 

तुरंत मैं अच्छा अभ्यास करने का सुझाव देता हूं, ताकि एक दिन यह पता न चले कि प्रकार में _id संपत्ति उस वर्ग या उसके वंशजों में इस्तेमाल होने वाले संघर्षों के साथ, उपसर्गों के साथ प्रकारों के गुणों को लिखें:

 trait WithId { protected $_WithId_id = null; protected $_WithId_checked = false; //... public function getId() { return $this->_WithId_id; } public function setId($id) { $this->_WithId_id = $id; } } 

क्षेत्र

यह समझना महत्वपूर्ण है कि विशेषता के भीतर विभिन्न कॉल को कैसे हल किया जाएगा। यह लक्ष्य वर्ग में "कॉपी-पेस्ट" कोड के रूप में विशेषता को जोड़ने के बारे में सोचने में शासन की मदद करेगा। पहले उदाहरण में, दुभाषिया, जैसा कि यह था, क्रमशः Human वर्ग में whoAmI पद्धति का "कॉपी-पेस्ट" बनाया गया, सभी parent को कॉल, self , $this काम करेगा और साथ ही साथ क्लास के तरीकों में कॉल भी। एक अपवाद कुछ मैजिक whoAmI होंगे, उदाहरण के लिए, whoAmI __METHOD__ === 'Pprint :: whoAmI' के अंदर।

विशेषता विधियों के अंदर, ऑब्जेक्ट की सभी संपत्तियां सीधे पहुंच के लिए उपलब्ध हैं, कोई अतिरिक्त स्कोप नहीं जोड़ा गया है। कोई व्यक्ति केवल __toString को कॉल करने के बजाय $this->_name प्राप्त कर सकता है। हालांकि, ऐसा करने से पहले कुछ समय सोचने के लायक है, क्योंकि जटिल कार्यान्वयन पर यह काफी भ्रम पैदा करेगा। मैं आपको सलाह दूंगा कि आप हमेशा स्पष्ट विधियों का उपयोग करें, यदि आवश्यक हो, यहां तक ​​कि उन्हें इंटरफ़ेस में भी वर्णित करें और इसे लागू करने के लिए कक्षाओं को "मजबूर" करें।

स्थैतिक तरीके और गुण

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

स्थिर संपत्तियों के भंडारण पर प्रतिबंध को दरकिनार किया जा सकता है, जैसा कि मैं बाद में जादू की अपील के साथ दिखाऊंगा।

अपने आप के साथ और कक्षा के तरीकों के प्रकार प्रकार का संयोग

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

यदि कक्षा द्वारा निर्दिष्ट कई प्रकार समान विधियों का उपयोग करते हैं, तो php कक्षा के आरंभीकरण स्तर पर एक त्रुटि फेंक देगा:

 trait A { public function abc() {} } trait B { public function abc() {} } class C { use A, B; } //Fatal error: Trait method abc has not been applied, //because there are collisions with other trait methods //on C in %FILE% on line %line% 

insteadof लिए आता है, जिसकी मदद से सभी संघर्षों को हल करना आवश्यक होगा।

एक मुश्किल त्रुटि तब हो सकती है जब टकराव का कारण वाला तरीका भी वर्ग में परिभाषित किया गया हो, जिस स्थिति में php इस चेक को छोड़ देगा, क्योंकि वह केवल "जीवित" गुण विधियों की जाँच करता है:

 trait A { public function abc() {} } trait B { public function abc() {} } class C { use A, B; public function abc() {} } //OK 

कुछ समय बाद, abc विधि को मूल वर्ग में स्थानांतरित करने पर, हमें विशेषता विधियों की टक्कर में एक अजीब त्रुटि मिलती है, जो भ्रामक हो सकती है। तो टक्करों को पहले से हल किया जाता है। ( दूसरी तरफ, यदि कोड में प्रकार और वर्ग के तरीके समान हैं, तो कुछ गलत है। )

किसी अन्य प्रकार और श्रेणी के गुणों के साथ गुण मिलान करें

इस बिंदु पर, अप्रिय समस्याओं का इंतजार है। तुरंत एक उदाहरण:

 trait WithId { protected $_id = false; //protected $_var = 'a'; public function getId() { return $this->_id; } //... } trait WithId2 { protected $_id = null; //protected $_var = null; //... } class A { use WithId, WithId2; } class B { use WithId2, WithId; } class C { use WithId; protected $_id = '0'; } // $a = new A(); var_dump($a->getId()); //NULL $b = new B(); var_dump($b->getId()); //false $c = new C(); var_dump($c->getId()); //false (!) //  $_var // WithId and WithId2 define the same property ($_var) // in the composition of A. However, the definition differs // and is considered incompatible. Class was composed // in %FILE% on line %LINE% 

मैं समझाता हूं। सामान्य स्थिति में, अपने या प्रकार और वर्ग के गुणों के बीच के प्रकारों के गुणों को प्रतिच्छेद करते समय, एक त्रुटि उत्पन्न होती है। लेकिन किसी कारण के लिए "संगत" गुणों के लिए एक अपवाद बनाया गया है और वे "जो अंतिम है, वह सही है" के सिद्धांत पर काम करता है। इसलिए, कक्षा A , getId NULL निकला, और कक्षा B , यह गलत निकला। इस मामले में, वर्ग के गुणों को प्रकार की संपत्ति से कम माना जाता है (तरीकों के साथ यह विपरीत है) और C में अपेक्षित '0' के बजाय हम गलत हैं।

जिन मूल्यों को संगत माना जाता है, वे गैर-सख्त तुलनाएँ हैं, जो सच देते हैं, और चूंकि php में बहुत सारे निहितार्थ रूपांतरण हैं, इसलिए लौटे मूल्यों की कड़ाई से तुलना करने पर अप्रिय त्रुटियां हो सकती हैं।

 var_dump(null == false); //true var_dump('0' == false); //true var_dump('a' == null); //false 

तो ऊपर प्रस्तावित उपसर्गों के साथ अभ्यास ऐसे मामलों में उपयोगी होगा। मुझे उम्मीद है कि कार्यान्वयन के इस हिस्से को रिलीज के लिए संशोधित किया जाएगा।

लक्षणों में त्रुटियां और अपवाद

यदि आप mnemonic rule trait == "कॉपी-पेस्ट" का अनुसरण करते हैं, तो त्रुटियों के साथ सब कुछ तुरंत स्पष्ट हो जाता है:

 <?php trait Slug { public function error() { echo $this->a; //5 } public function someMethod() { $this->error(); } public function testExc() { throw new Exception('Test'); //16 } } class Brain { use Slug; public function plurk() { $this->testExc(); //25 } } error_reporting(E_ALL); $b = new Brain(); $b->someMethod(); //Notice: Undefined property: Brain::$a in %FILE% on line 5 try { $b->plurk(); //35 } catch(Exception $e) { echo $e; } // exception 'Exception' with message 'Test' in %FILE%:16 // Stack trace: // #0 %FILE%(25): Brain->testExc() // #1 %FILE%(35): Brain->plurk() // #2 {main} 

ऑब्जेक्ट अब यह नहीं जानता है कि यह कहाँ से आया था जिसमें एक नोटिस या अपवाद था, लेकिन यह स्टैक ट्रेस में कोड की पंक्तियों द्वारा पाया जा सकता है जिसमें कॉल थे। यदि आप अलग-अलग फ़ाइलों में लक्षण संग्रहीत करते हैं, तो यह निर्धारित करना और भी आसान होगा।

सफेद काले जादू का एक सा

मैं प्रकारों के साथ कुछ गंदे चालें दिखाऊंगा, उन्हें अपने जोखिम और जोखिम पर उपयोग करूंगा।

एक प्रकार विधि निकालना

उदाहरण के लिए, जब यह उर्फ ​​दिया गया था, तो एक विशेषता विधि निकालने के लिए, आप यह कर सकते हैं:

 trait A { public function a() {} public function b() {} } trait B { public function d() { $this->e(); } public function e() {} } class C { use A { //   A::b insteadof A; A::b as c; } use B { //   B::e insteadof B; } } echo join(", ", get_class_methods('C')), PHP_EOL; //a, c, d 

लेकिन इस दृष्टिकोण में, एक बड़ा खतरा है, क्योंकि कुछ प्रकार के तरीके संभावित रूप से अन्य तरीकों को कॉल कर सकते हैं:

 $c = new C(); $c->d(); //Fatal error: Call to undefined method C::e() 

नाम बदलने के दौरान, प्रकार नहीं जानता कि विधि का नाम बदल दिया गया है। इसलिए, डिफ़ॉल्ट रूप से, उपनाम को निर्दिष्ट करते समय, मूल विधि बच जाती है।

"इनहेरिटेंस" प्रकारों में

एक समान चाल का उपयोग करके, आप "मूल" तरीकों को "मूल" विधियों को कॉल करने की क्षमता के साथ "विरासत" को लागू कर सकते हैं।

 trait Namer { public function getName() { return 'Name'; } } trait Namer2 { public function getName() { return 'Name2'; } } trait Supernamer { use Namer, Namer2 { Namer::getName insteadof Namer; Namer::getName as protected _Namer_getName_; Namer2::getName insteadof Namer2; Namer2::getName as protected _Namer2_getName_; } public function getName() { return $this->_Namer_getName_() . $this->_Namer2_getName_(); } } 

लक्षण के साथ सिंगलटन को लागू करने के दो तरीके

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

पहला उस वर्ग का नाम प्राप्त करना है, जिसे इसे विधि के अंदर बुलाया गया था, और फिर भंडारण के रूप में एक स्थिर विधि के साथ एक अलग वर्ग का उपयोग करें, कुछ इस तरह से:

 trait Singleton { static public function getInstance() { $class = get_called_class(); //  static:: if (!Storage::hasInstance($class)) { $new = new static(); Storage::setInstance($class, $new); } return Storage::getInstance($class); } } 

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

 trait Singleton { static public function getInstance() { static $instance = null; if ($instance === null) { $instance = new static(); } return $instance; } } class MyClass { use Singleton; } class MyExtClass extends MyClass {} echo get_class(MyClass::getInstance()), PHP_EOL; //MyClass echo get_class(MyExtClass::getInstance()), PHP_EOL; //MyExtClass 

पुनश्च

लक्षण के साथ काम करने पर मदद और दिलचस्प विचारों के लिए धन्यवाद aveic ।