जावास्क्रिप्ट पैटर्न छद्म-शास्त्रीय (छद्म-शास्त्रीय)

एक पैटर्न में, कंस्ट्रक्टर में एक ऑब्जेक्ट बनाया जाता है, और इसके तरीकों को प्रोटोटाइप में घोषित किया जाता है।

इस पैटर्न का उपयोग Google क्लोजर लाइब्रेरी जैसे चौखटे में किया जाता है। नेटिव जावास्क्रिप्ट ऑब्जेक्ट भी इस पैटर्न का उपयोग करते हैं।

छद्म श्रेणी की घोषणा

Pseudo-class शब्द इसलिए चुना गया क्योंकि जावास्क्रिप्ट में C, Java, PHP आदि जैसी अन्य भाषाओं की तरह कक्षाएं नहीं हैं, लेकिन यह पैटर्न क्लास की परिभाषा के करीब है।

एक छद्म वर्ग में एक रचनाकार फ़ंक्शन और विधियाँ होती हैं।

उदाहरण के लिए, Animal छद्म वर्ग में एक sit विधि और 2 गुण होते हैं:

 function Animal(name) { this.name = name } Animal.prototype = { canWalk: true, sit: function() { this.canWalk = false alert(this.name + ' sits down.') } } var animal = new Animal('Pet') // (1) alert(animal.canWalk) // true animal.sit() // (2) alert(animal.canWalk) // false 

1. जब new Animal(name) को बुलाया जाता है, तो ऑब्जेक्ट को __proto__ एक __proto__ लिंक Animal.prototype (आरेख के दाईं ओर देखें)।
2. animal.sit विधि उदाहरण में animal.canWalk को संशोधित animal.canWalk है, इसलिए हमारा जानवर अब नहीं चल सकता है, जबकि अन्य कर सकते हैं।

छद्म श्रेणी स्कीमा:

1. डिफ़ॉल्ट विधियों और गुणों को प्रोटोटाइप में परिभाषित किया गया है।
2. prototype में विधियां इसका उपयोग करती हैं, जो वर्तमान वस्तु को इंगित करता है क्योंकि इस का मूल्य कॉल के संदर्भ पर निर्भर करता है। इसलिए, animal.sit() this animal को संदर्भित करता है।

विरासत

चलिए एक नया वर्ग बनाते हैं जो Animal से विरासत में आएगा, उदाहरण के लिए Rabbit

 function Rabbit(name) { this.name = name } Rabbit.prototype.jump = function() { this.canWalk = true alert(this.name + ' jumps!') } var rabbit = new Rabbit('John') 

जैसा कि आप देख सकते हैं, खरगोश की Animal के समान संरचना है - पद्धति को प्रोटोटाइप में परिभाषित किया गया है।

Animal से विरासत में, आपको ऐसा करने की आवश्यकता है Rabbit.prototype.__proto__ == Animal.prototype । यह एक प्राकृतिक आवश्यकता है, क्योंकि अगर विधि Rabbit.prototype में नहीं पाई Rabbit.prototype , तो हम इसके लिए मूल Animal.prototype के तरीकों की Animal.prototype ।

इस तरह, उदाहरण के लिए:



इसे लागू करने के लिए, हमें पहले एक खाली Rabbit.prototype ऑब्जेक्ट बनाना होगा जो कि Rabbit.prototype से विरासत में मिला हो और फिर तरीके जोड़े।

 function Rabbit(name) { this.name = name } Rabbit.prototype = inherit(Animal.prototype) Rabbit.prototype.jump = function() { ... } 

inherit निर्दिष्ट __proto__ साथ एक खाली ऑब्जेक्ट बनाता है:

 function inherit(proto) { function F() {} F.prototype = proto return new F } 

यहाँ अंत में क्या हुआ है:

 // Animal function Animal(name) { this.name = name } // Animal methods Animal.prototype = { canWalk: true, sit: function() { this.canWalk = false alert(this.name + ' sits down.') } } // Rabbit function Rabbit(name) { this.name = name } // inherit Rabbit.prototype = inherit(Animal.prototype) // Rabbit methods Rabbit.prototype.jump = function() { this.canWalk = true alert(this.name + ' jumps!') } // Usage var rabbit = new Rabbit('Sniffer') rabbit.sit() // Sniffer sits. rabbit.jump() // Sniffer jumps! 

वंशानुक्रम के लिए new Animal उपयोग न करें

एक प्रसिद्ध, लेकिन सही तरीका नहीं है वंशानुक्रम के लिए, जब Rabbit.prototype = inherit(Animal.prototype) बजाय। Rabbit.prototype = inherit(Animal.prototype) लोग निम्न कार्य करते हैं:

 // inherit from Animal Rabbit.prototype = new Animal() 

नतीजतन, हमें प्रोटोटाइप में एक new Animal मिलता है। वंशानुक्रम काम करता है क्योंकि new Animal स्वाभाविक रूप से Animal.prototype विरासत में Animal.prototype ।

... लेकिन किसने कहा कि new Animal() को बिना name बुलाया जा सकता है? एक निर्माता को कड़ाई से तर्क की आवश्यकता हो सकती है और उनके बिना मर सकते हैं।

वास्तव में, समस्या इससे कहीं अधिक वैचारिक है। हम Animal नहीं बनाना चाहते। हम सिर्फ उससे विरासत में हासिल करना चाहते हैं।

यही कारण है कि Rabbit.prototype = inherit(Animal.prototype) बेहतर है। साइड इफेक्ट के बिना नीट विरासत।

सुपरक्लास कंस्ट्रक्टर कॉल

सुपरक्लास कंस्ट्रक्टर को अब स्वचालित रूप से कहा जाता है। हम इसे वर्तमान ऑब्जेक्ट के लिए Animal.apply() का उपयोग करके हैंडल के साथ कॉल कर सकते हैं:

 function Rabbit(name) { Animal.apply(this, arguments) } 

यह कोड Animal निर्माता को वर्तमान वस्तु के संदर्भ में निष्पादित करता है और यह उदाहरण name सेट करता है।

विधि पुनर्परिभाषित (बहुरूपता)

मूल विधि को ओवरराइड करने के लिए, इसे बच्चे के प्रोटोटाइप में बदलें:

 Rabbit.prototype.sit = function() { alert(this.name + ' sits in a rabbity way.') } 

जब rabbit.sit() कहा जाता है, तो श्रृंखला को rabbit -> Rabbit.prototype -> Animal.prototype द्वारा खोजा जाता है rabbit -> Rabbit.prototype -> Animal.prototype और Rabbit.prototype तक पहुँचने से पहले इसे Rabbit.prototype में ढूँढता है।

बेशक, हम इसे अलग-अलग तरीके से परिभाषित कर सकते हैं - सीधे वस्तु में:

 rabbit.sit = function() { alert('A special sit of this very rabbit ' + this.name) } 

ओवरराइड करने के बाद मूल विधि को कॉल करना

विधि को ओवरराइड करने के बाद, हमें अभी भी मूल विधि को कॉल करने की आवश्यकता हो सकती है। यह संभव है अगर हम सीधे मूल प्रोटोटाइप की ओर मुड़ते हैं।

 Rabbit.prototype.sit = function() { alert('calling superclass sit:') Animal.prototype.sit.apply(this, arguments) } 

सभी मूल तरीकों को apply/call साथ apply/call किया जाता है जहां वर्तमान वस्तु को this रूप में पारित किया जाता है। Animal.prototype.sit() लिए एक साधारण कॉल this रूप में Animal.prototype का उपयोग करेगा।

चीनी: माता-पिता के सीधे संदर्भ को हटाना

पिछले उदाहरण में, हमने सीधे पैरेंट क्लास को बुलाया। एक निर्माता के रूप में: Animal.apply... , या एक विधि: Animal.prototype.sit.apply...

वास्तव में, हमें ऐसा नहीं करना चाहिए। अपवर्तन के दौरान, नाम बदला जा सकता है या मध्यवर्ती वर्गों को पदानुक्रम में जोड़ा जा सकता है।

आमतौर पर, प्रोग्रामिंग भाषाएं आपको विशेष कीवर्ड का उपयोग करके मूल विधियों को कॉल करने की अनुमति देती हैं, जैसे कि parent.method() या super() ।

लेकिन जावास्क्रिप्ट में ऐसा नहीं है, लेकिन हम इसे मॉडल कर सकते हैं।

निम्नलिखित कार्य वंशानुक्रम का विस्तार करता है और इसके प्रत्यक्ष संदर्भ के बिना अभिभावक और निर्माता को भी सेट करता है:

 function extend(Child, Parent) { Child.prototype = inherit(Parent.prototype) Child.prototype.constructor = Child Child.parent = Parent.prototype } 

तो यहाँ आप उपयोग कर सकते हैं:

 function Rabbit(name) { Rabbit.parent.constructor.apply(this, arguments) // super constructor } extend(Rabbit, Animal) Rabbit.prototype.run = function() { Rabbit.parent.run.apply(this, arguments) // parent method alert("fast") } 

नतीजतन, हम Animal नाम बदल सकते हैं या एक मध्यवर्ती GrassEatingAnimal क्लास बना सकते हैं और केवल Animal और extend(...) प्रभावित होंगे।

निजी और सुरक्षित तरीके (इनकैप्सुलेशन)

संरक्षित तरीकों और गुणों का नामकरण सम्मेलन द्वारा समर्थित है। अंडरस्कोर '_' से शुरू होने वाले तरीकों को बाहर से नहीं बुलाया जाना चाहिए (वास्तव में वे कर सकते हैं)।



निजी तरीके समर्थित नहीं हैं।

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

विधायक में स्थैतिक विधियों और गुणों को परिभाषित किया गया है:

 function Animal() { Animal.count++ } Animal.count = 0 new Animal() new Animal() alert(Animal.count) // 2 

कुल मिलाकर

यहाँ हमारा सुपर-मेगा-ओओपी ढांचा है:

 function extend(Child, Parent) { Child.prototype = inherit(Parent.prototype) Child.prototype.constructor = Child Child.parent = Parent.prototype } function inherit(proto) { function F() {} F.prototype = proto return new F } 

का उपयोग करें:

 // --------- the base object ------------ function Animal(name) { this.name = name } // methods Animal.prototype.run = function() { alert(this + " is running!") } Animal.prototype.toString = function() { return this.name } // --------- the child object ----------- function Rabbit(name) { Rabbit.parent.constructor.apply(this, arguments) } // inherit extend(Rabbit, Animal) // override Rabbit.prototype.run = function() { Rabbit.parent.run.apply(this) alert(this + " bounces high into the sky!") } var rabbit = new Rabbit('Jumper') rabbit.run() 

आप हमारे ढांचे में थोड़ी सी चीनी जोड़ सकते हैं, उदाहरण के लिए, एक फ़ंक्शन जो एक वस्तु से दूसरे में गुणों को कॉपी करता है:

 mixin(Animal.prototype, { run: ..., toString: ...}) 

लेकिन वास्तव में आपको इस OOP पैटर्न का उपयोग करने की आवश्यकता नहीं है। केवल दो कार्य इसे संभाल सकते हैं।