🎹 🐜 🌳 जावास्क्रिप्ट में कक्षाएं, वस्तुएं और विरासत 🙌🏽 👩‍💻 🙅🏼

हाल ही में, हैबर के कार्यालय में, मैं अपने सहयोगियों को ऑब्जेक्ट ओरिएंटेशन और जावास्क्रिप्ट में वर्ग विरासत पर एक छोटी रिपोर्ट पढ़ना चाहता था।

तथ्य यह है कि एक समय में मुझे यह जानकर खुशी हुई कि मैं अपनी खुद की वस्तुओं का निर्माण कैसे कर सकता हूं और विरासत श्रृंखलाएं बना सकता हूं, और जो मुझे अन्य निष्कर्षों और टिप्पणियों के साथ मिला, उसे साझा करने का फैसला किया। (=

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

इस तथ्य का लाभ उठाते हुए कि संगोष्ठी को “अगले शुक्रवार तक” के लिए स्थगित कर दिया गया था, मैंने सेमिनार के पाठ को नेट पर प्रकाशित करने का फैसला किया ताकि मेरा उत्साह किसी और के लिए उपयोगी हो।

पूरे पाठ को 5 खंडों में विभाजित किया गया है:

जावा स्क्रिप्ट में ओओपी (1/5): ऑब्जेक्ट
जावा स्क्रिप्ट में OOP (2/5): कक्षाएं
जावा स्क्रिप्ट में ओओपी (3/5): कक्षा के गुण और तरीके
जावा स्क्रिप्ट में OOP (4/5): क्लास इनहेरिटेंस
जावा स्क्रिप्ट में OOP (5/5): उपयोगी लिंक्स

जावा स्क्रिप्ट में ओओपी (1/5): ऑब्जेक्ट

जावास्क्रिप्ट में सब कुछ, वास्तव में, एक वस्तु है। एक सरणी एक वस्तु है। एक कार्य एक वस्तु है। एक वस्तु भी एक वस्तु है। तो एक वस्तु क्या है? एक वस्तु गुणों का एक संग्रह है। प्रत्येक संपत्ति एक नाम-मूल्य जोड़ी है। संपत्ति का नाम एक स्ट्रिंग है, और एक संपत्ति का मूल्य एक स्ट्रिंग, एक संख्या, एक बूलियन मूल्य, या एक वस्तु (एक सरणी और एक फ़ंक्शन सहित) है।

जब हम किसी प्रकार के चर को परिभाषित करते हैं, उदाहरण के लिए:

var s = 'hello world'; alert(typeof s); //  string

हम, वास्तव में, स्पष्ट रूप से किसी वस्तु की संपत्ति निर्धारित करते हैं। इस स्थिति में, ऐसा ऑब्जेक्ट वैश्विक विंडो ऑब्जेक्ट होगा:

 alert (s == window.s); //  true alert (typeof window); //  object

इसके अलावा, यह window.s प्रॉपर्टी अपने आप में एक ऑब्जेक्ट है, क्योंकि इसमें पहले से ही परिभाषित गुणों का अपना संग्रह है:

 alert(s.length); //  11 (   )

इस सब के साथ, पहली नज़र में, यह एक साधारण स्ट्रिंग शाब्दिक है!

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

 var s = 'futurico'; //    s  window (window.s) var f = function(){ //    f  window (window.f) alert(this == window); //  true alert(this.s); //  'futurico' } f(); //   f  window (window.f()) var o = {}; //    o  window (window.o) os = 'karaboz'; //    s  window.o (window.os) of = function(){ //    f  window.o (window.of) alert(this == o); //  true alert(this.s); //  'karaboz' } of(); //   f  window.o (window.of())

कंस्ट्रक्टर फ़ंक्शन का उपयोग करके एक ऑब्जेक्ट बनाया जाता है जो ऑब्जेक्ट और new

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

उदाहरण के लिए, जब हम एक स्ट्रिंग चर घोषित करते हैं:

 var str='karaboz';

हम अंतर्निहित निर्माण फ़ंक्शन को स्पष्ट रूप से कहते हैं:

 var str = new String('karaboz');

और इस प्रकार String

कक्षा का एक ऑब्जेक्ट (उदाहरण) बनाएं।

अन्य सभी जावास्क्रिप्ट डेटा प्रकारों के लिए एक ही कथन सही है:

 //  var num = 12345.6789; // var num = new Number(12345.6789); //   var bul = true; // var c = new Boolean(true); //  var fun = function(x){var p = x}; // var fun = new Function('x', 'var p = x'); //  var arr = ['a', 'b', 'c']; // var arr = new Array('a', 'b', 'c'); //  var obj = {}; // var obj = new Object();

निर्माण के तुरंत बाद इन सभी वस्तुओं में उनके निर्माण कार्यों (वर्गों) में वर्णित सभी गुण और विधियां हैं:

 alert(num.toFixed(1)); //  12345.6 alert(arr.length); //  3

वास्तव में, जावास्क्रिप्ट दुभाषिया थोड़ा पेचीदा मामला है क्योंकि यह पिछले उदाहरण से लग सकता है। तो, इस तथ्य के बावजूद कि निम्न कोड दो चर ( String

वर्ग की वस्तुओं) की समानता को दर्शाता है:

 var str1 = 'karaboz'; var str2 = new String('karaboz'); alert(str1 == str2); //  true

जब str1 के लिए एक नई कस्टम विधि को परिभाषित करने का प्रयास किया जाता है, तो हमें एक त्रुटि मिलती है:

 str1.tell = function(){ alert(this); } str1.tell(); //   'str1.tell is not a function'

उसी समय, str2 के लिए, सब कुछ काम करेगा, जैसा कि हम उम्मीद करते हैं:

 str2.tell = function(){ alert(this); } str2.tell(); //  'karaboz'

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

 var s = 'futurico'; //    s  window (window.s) var f = function(){ //    f  window (window.f) alert(this == window); //  true alert(this.s); //  'futurico' } f(); //   f  window (window.f()) fs = 'karaboz'; //    s  window.f (window.fs) fm = function(){ //    m  window.f (window.fm) alert(this == f); //  true alert(this.s); //  'karaboz' } fm(); //   m  window.f (window.fm())

यहां हम स्पष्ट रूप से देखते हैं कि वैश्विक विंडो ऑब्जेक्ट की एक विधि के रूप में बनाया गया फ़ंक्शन f, स्वयं एक ऐसी वस्तु है जिसके अपने गुण और विधियां हो सकती हैं!

जावा स्क्रिप्ट में OOP (2/5): कक्षाएं

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

 // - -    var Class = function(p){ alert('My name is constructor'); this.p = p; }

और इस नए वर्ग का एक ऑब्जेक्ट बनाने के लिए, हमें नए कीवर्ड का उपयोग करते हुए इसे एक सामान्य फ़ंक्शन के रूप में कॉल करना होगा। इस स्थिति में, कंस्ट्रक्टर फ़ंक्शन के अंदर का यह कीवर्ड अब नए बनाए गए ऑब्जेक्ट को इंगित करेगा:

 var o = new Class('karaboz'); alert(o); //  [Object object] alert(op); //  'karaboz' -     o

यदि आप वेरिएबल ओ की कोशिश करते हैं तो बस क्लास () फ़ंक्शन को कॉल करें - नए कीवर्ड के बिना, फिर कोई ऑब्जेक्ट नहीं बनाया जाएगा:

 var o = Class('karaboz'); //   window.Class() alert(o); //  undefined,   ,    Class() alert(window.p); //  'karaboz' -      window

एक फ़ंक्शन बनाते समय, जावास्क्रिप्ट स्वचालित रूप से इसके लिए एक .prototype

संपत्ति बनाता है। .prototype

फ़ंक्शन के .prototype

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

 Class.prototype.method = function(){ alert('my name is .method'); }

अब हम इस विधि को वस्तु का एक तरीका कह सकते हैं:

 o.method(); // !

जब ऑब्जेक्ट की संपत्ति को बुलाया जाता है, तो इसे पहले ऑब्जेक्ट में ही खोजा जाता है, और यदि यह वहां नहीं दिखाई देता है, तो इंटरप्रेटर .prototype

फ़ंक्शन के .prototype

में दिखता है।

इसलिए, एक ऑब्जेक्ट बनाते समय, .constructor

गुण पहले से ही इसमें मौजूद है, जो इस ऑब्जेक्ट को बनाने वाले निर्माता फ़ंक्शन को इंगित करता है:

 alert(o.constructor == Class); //  true

ध्यान दें कि हमने इस तरह की संपत्ति को ऑब्जेक्ट में ही परिभाषित नहीं किया है। इंटरप्रेटर, ऑब्जेक्ट में .constructor

प्रॉपर्टी को न पाकर, इसे कंस्ट्रक्टर फ़ंक्शन के .prototype से लेता है जिसने ऑब्जेक्ट बनाया था। की जाँच करें:

 alert(Class.prototype.constructor == Class); //  true

यह ध्यान दिया जाना चाहिए कि .prototype

केवल निर्माण कार्य के लिए मौजूद है, लेकिन इसके आधार पर बनाई गई वस्तु के लिए नहीं:

 alert(o.prototype); //  undefined alert(o.constructor.prototype); //  [Object object]

.prototype

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

 var s = 'karaboz'; s.constructor.prototype.tell = function(){ alert(this); } s.tell(); //     ,   'karaboz'

आप इन वस्तुओं के बिल्ट-इन प्रकारों के माध्यम से सीधे-सीधे ऑब्जेक्ट्स के लिए एक नई प्रॉपर्टी या विधि भी सेट कर सकते हैं:

 String.prototype.tell = function(){ alert(this); }

वैसे, हमने एक बार फिर से इस कथन की पुष्टि की है कि जावास्क्रिप्ट में सब कुछ एक वस्तु (=) है

जावा स्क्रिप्ट में ओओपी (3/5): कक्षा के गुण और तरीके

एक वर्ग (वर्ग के सदस्य) के गुण और तरीके सार्वजनिक (सार्वजनिक), निजी (निजी), विशेषाधिकार प्राप्त (विशेषाधिकार प्राप्त) और स्थैतिक (स्थैतिक) हो सकते हैं।

जनता के सदस्य

ओपन ऐसे गुण और विधियाँ हैं जिन्हें ऑब्जेक्ट के बाहर स्थित किसी भी कोड द्वारा सीधे पढ़ा, संशोधित, हटाया या जोड़ा जा सकता है।

सार्वजनिक गुण निर्माण फ़ंक्शन के अंदर .this

का उपयोग करके सेट किए जाते हैं:

 var Class = function(p){ this.p = p; } var o = new Class('karaboz'); alert(op); //  'karaboz' op = 'mertas'; alert(op); //  'mertas'

सार्वजनिक विधियों को .prototype

फ़ंक्शन का उपयोग करके परिभाषित किया .prototype

है:

 Class.prototype.method = function(){ alert('my name is .method'); } obj.method(); //  'my name is .method' obj.method = function(){ alert('my name is .method, but I am new one!'); } obj.method(); //  'my name is .method, but I am new one!'

.method

ऑब्जेक्ट को .method

मेथड असाइन करते .method

, हम .prototype

फ़ंक्शन के .prototype

में एक ही नाम की विधि को नहीं बदलते हैं, हम केवल दुभाषिया से इसे बंद करते हैं, हमारी वस्तु में उसी नाम के साथ एक नई प्रॉपर्टी बनाते हैं। यानी सभी नई बनाई गई वस्तुओं में अभी भी .prototype

से मानक विधि .prototype

।

हम .prototype

से .prototype

से देखने और उपयोग करने की सुविधा दे सकते हैं। ऐसा करने के लिए, केवल ऑब्जेक्ट की .method

संपत्ति को हटा दें:

 delete o.method; o.method(); //   'my name is .method'

निर्माण कार्य के .prototype

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

निजी सदस्य

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

 var Class = function(p){ var secret = p; var count = 3; var counter = function(){ count –; if(count > 0){ return true; } else { return false; } } }

प्रारंभिक होने पर ऑब्जेक्ट में secret

, count

और counter

विधियां बनाई जाती हैं। उन्हें बंद कहा जाता है क्योंकि उन्हें ऑब्जेक्ट के बाहर कोड या ऑब्जेक्ट के सार्वजनिक तरीकों से ही एक्सेस नहीं किया जा सकता है। इन निजी गुणों का उपयोग करने के तरीके को समझने के लिए, आपको विशेषाधिकार प्राप्त तरीकों की ओर मुड़ने की आवश्यकता है।

विशेषाधिकार प्राप्त विधियाँ

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

इस कीवर्ड के उपयोग से पसंदीदा विधि को कंस्ट्रक्टर में परिभाषित किया गया है:

 var Class = function(p){ var secret = p; var count = 3; var counter = function(){ if(count > 0){ count –; return true; } else { return false; } } this.tellSecret = function(){ if(counter()){ return secret; } else { return null; } } } var o = new Class('12345'); alert(o.tellSecret()); //  '12345' alert(o.tellSecret()); //  '12345' alert(o.tellSecret()); //  '12345' alert(o.tellSecret()); //  null //      counter, // a   ,       o.counter = function(){ return true; } alert(o.tellSecret()); //    null

.tellSecret

पसंदीदा तरीका है। यह निजी संपत्ति को पहले तीन कॉल के लिए secret

, और बाद में सभी के लिए null

। हर बार .tellSecret

निजी पद्धति counter

कॉल करता है, जो स्वयं ऑब्जेक्ट के निजी गुणों तक पहुंच रखता है। किसी भी कोड की .tellSecret

पद्धति तक पहुंच है, लेकिन यह ऑब्जेक्ट के निजी सदस्यों को सीधे पहुंच नहीं देता है।

.prototype

के माध्यम से बनाई गई सार्वजनिक विधियों के विपरीत, विशेषाधिकार प्राप्त विधि की एक प्रति बनाई गई प्रत्येक वस्तु में बनाई जाती है, जो स्वाभाविक रूप से अन्य मेमोरी खपत को .prototype

। निजी और विशेषाधिकार प्राप्त सदस्यों को केवल उस समय बनाया जाता है जब ऑब्जेक्ट को प्रारंभ किया जाता है और बाद में बदला नहीं जा सकता।

स्थैतिक सदस्य

स्थैतिक गुण और विधियाँ गुण और विधियाँ कार्य से जुड़ी हुई हैं (स्वयं वर्ग के लिए)। इसलिए, उन्हें वर्ग गुण और विधियाँ भी कहा जाता है। वे वस्तु के अंदर और बाहर किसी भी कोड के लिए उपलब्ध हैं:

 var Class = function(p){ this.p = p; } Class.prototype.tell = function(word){ alert(this.p + ' ' + word + ' ' + this.constructor.p); // alert(this.p + ' ' + word + ' ' + Class.p); } Class.p = 'futurico'; var o = new Class('karaboz'); o.tell('love'); //  'karaboz loves futurico';

बंद (बंद)

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

ऑपरेटर का उपयोग करते function

, तो हम हमेशा एक फ़ंक्शन नहीं, बल्कि एक क्लोजर बनाते हैं। एक क्लोजर सभी वेरिएबल्स के मूल्यों को याद करता है जो उस संदर्भ में मौजूद थे जिसने इस क्लोजर को बनाया था, तब भी जब फ़ंक्शन का उपयोग उस संदर्भ के बाहर किया जाता है जिसने इसे बनाया था।

 var createFunc = function(param){ var closureParam = param; //  var returnedFunc = function(){alert(closureParam);} return returnedFunc; } var f = createFunc('karaboz');

अब, यदि हम चर f

को देखते हैं, तो हम देखेंगे कि यह एक सामान्य कार्य है, जिसके शरीर में closureParam

पैरामीटर निहित है, जो कि f

आसपास के संदर्भ में कहीं भी अपरिभाषित है और सिद्धांत रूप में एक त्रुटि देना चाहिए:

 alert(f); // : function(){alert(closureParam);}

हालाँकि, कोई त्रुटि नहीं होगी, function(){alert(closureParam);}

क्लोजर प्रभाव के लिए धन्यवाद closureParam

को उस संदर्भ से याद करता है closureParam

इसे उत्पन्न किया था:

 f(); //  'karaboz'

यदि हम ऊपर वर्णित विशेषाधिकार विधि को याद करते हैं। अब हम बता सकते हैं कि यह कैसे काम करता है। यह विधि .tellSecret

संदर्भ में घोषित निजी फ़ंक्शन count()

और निजी संपत्ति secret

दोनों को याद .tellSecret

। उसी समय, जब count()

को .tellSecret

अंदर कहा जाता है, यह अंतिम कार्य, बदले में, इसके शरीर में उपयोग किए जाने वाले count()

.tellSecret

याद करता है।

जावा स्क्रिप्ट में OOP (4/5): क्लास इनहेरिटेंस

वर्ग उत्तराधिकार के मूल सिद्धांत:

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

जावास्क्रिप्ट में क्लासिक क्लास इनहेरिटेंस बनाने के लिए कोई उपकरण नहीं है। इसके बजाय, ऑब्जेक्ट की .prototype

संपत्ति के आधार पर उत्तराधिकार है: जब ऑब्जेक्ट की विधि को कहा जाता है, तो इंटरप्रिटर ऑब्जेक्ट के गुणों में इस पद्धति की खोज करता है, और यदि यह वहां की विधि नहीं .prototype

है, तो यह इस ऑब्जेक्ट के .prototype

फ़ंक्शन की संपत्ति (ऑब्जेक्ट) में खोज करना जारी रखता है।

जावास्क्रिप्ट के इस व्यवहार को जानने के बाद, आइए दो वर्गों की एक विरासत बनाने की कोशिश करें:

 var Class = function(){ // -  this.className = 'Class'; } Class.prototype.method = function(){ //     alert('method of ' + this.className); } var ClassSub = function(){ // -  this.className = 'ClassSub'; } ClassSub.prototype = new Class(); //     .prototype  var objSub = new ClassSub(); //    ClassSub objSub.method(); // !  'method of ClassSub'

हम देखते हैं कि उपवर्ग .method

अपने .method

विरासत में मिला है (इसे अपने रूप में निष्पादित करता है)। यह कैसा चल रहा है? सबसे पहले, दुभाषिया objSub

ऑब्जेक्ट में .method

विधि की खोज करता objSub

और स्वाभाविक रूप से इसे वहां नहीं पाता है। इसके बाद, दुभाषिया ClassSub.prototype

कॉल ClassSub.prototype

और इस ऑब्जेक्ट के गुणों के बीच .method

की तलाश करता है। फिर से - इसमें कुछ भी नहीं मिलेगा: हम कहीं भी ClassSub.prototype.method = function(){}

समान कुछ भी सेट नहीं ClassSub.prototype.method = function(){}

। लेकिन ClassSub.prototype

ऑब्जेक्ट ClassSub.prototype

Class()

के कंस्ट्रक्टर फ़ंक्शन से बनाया गया है। इसलिए, ClassSub.prototype

ही आवश्यक गुण नहीं मिल रहे हैं, दुभाषिया इस ऑब्जेक्ट के .prototype

फ़ंक्शन को कॉल करता है। और पहले से ही यहां वह अनुरोधित विधि पाता है: Class.prototype.method = function(){}

।

हम एक सरल तुलना के साथ इस लंबे तर्क की पुष्टि करते हैं:

 // .method  objSub   .method  ClassSub.prototype alert(objSub.method == ClassSub.prototype.method); // true //  .method  ClassSub.prototype   .method  Class.prototype alert(ClassSub.prototype.method == Class.prototype.method); // true

प्रोटोटाइप की एक समान श्रृंखला मनमाने ढंग से लंबी हो सकती है, लेकिन किसी भी मामले में दुभाषिया की तलाश उस समय समाप्त हो जाएगी जब वह अंतर्निहित Object

क्लास से बनाई गई वस्तु (स्पष्ट या अंतर्निहित) को प्राप्त होती है। यदि Object.prototype

यह अभी भी अनुरोधित विधि को नहीं Object.prototype

है, तो यह एक त्रुटि लौटाएगा। Object

क्लास जावास्क्रिप्ट में बनाई गई कक्षाओं के किसी भी संभावित पदानुक्रम के शीर्ष पर स्थित है।

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

 ClassSub.prototype.method = function(){ //     alert('method of ' + this.className + ' but new one'); } ClassSub.prototype.methodSub = function(){ //     alert('methodSub of ' + this.className); }; //       objSub.method(); //  'method of ClassSub but new one' //       objSub.methodSub(); //  'methodSub of ClassSub' var obj = new Class(); //    Class //       obj.method(); //  'method of Class' //       obj.methodSub(); //   'obj.methodSub is not a function'

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

जब तक हम अधिक यथार्थवादी कोड लिखने की कोशिश नहीं करते तब तक सब कुछ सरल दिखता है। एक नियम के रूप में, एक निर्माण कार्य न केवल किसी वस्तु के गुणों को परिभाषित करता है, बल्कि कुछ प्रारंभिक कार्य भी करता है। उदाहरण के लिए, एक Animal

वर्ग बनाएं, जिसमें व्यक्ति का नाम एक पैरामीटर के रूप में पारित किया जाएगा, और प्रत्येक नया उदाहरण जन्म के समय चिल्लाएगा (=

 var Animal = function(name){ this.name = name; this.cry(); //      } Animal.prototype.cry = function(){ alert('whoa!'); } var animal_thing = new Animal('karaboz'); //  'whoa!';

अब कैट का एक उपवर्ग बनाएँ, जिसके उदाहरण चिल्लाए नहीं बल्कि म्याऊ करें:

 var Cat = function(name){ this.name = name; this.cry(); } Cat.prototype = new Animal(); //    Animal Cat.prototype.cry = function(){ //   .cry alert('meow!'); } var cat_thing = new Cat('mertas');

इस कोड को चलाने पर, हम दो चीखें नहीं सुनते हैं (वाह !, म्याऊ!), लेकिन तीन! (वाह !, वाह !, म्याऊ!) और मैं देख रहा हूँ। दूसरी चीख उसी क्षण होती है जब हम वंशानुक्रम Cat.prototype = new Animal () करते हैं। हम अनजाने में पशु वर्ग का एक उदाहरण बनाते हैं (और इसे जन्म के समय चिल्लाते हैं)। यानी हम उपवर्ग के किसी भी प्रकार का निर्माण करने से पहले ही सुपरक्लास आइडल का निर्माण कार्य चलाते हैं!

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

सुपरक्लास के कंस्ट्रक्टर फंक्शन के लिए सिंगल कॉल की समस्या का समाधान

शायद Animal

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

 Cat.prototype = Animal.prototype;

कोड चलाना, हम दो अपेक्षित चीखें सुनते हैं! लेकिन यह केवल लगता है कि समस्या हल हो गई है। आइए Animal

सुपरक्लास का एक और उदाहरण बनाने के लिए Cat

उपवर्ग का एक उदाहरण बनाने के तुरंत बाद प्रयास करें

 var animal_thing_new = new Animal('juks'); //  'meow!',      Cat!

यह उदाहरण कैट-क्लास की आवाज़ में चिल्लाता है! यह पता चला कि हमने समान नाम की मूल-श्रेणी विधि को फिर से लिखा है। बात यह है कि जब हम Cat.prototype = Animal.prototype

, तो हम संदर्भ द्वारा Cat.prototype ऑब्जेक्ट के लिए Animal.prototype ऑब्जेक्ट पास करते हैं (जैसा कि हमेशा तब होता है जब ऑब्जेक्ट किसी वैरिएबल को असाइन किया जाता है)। इसलिए, पहले एक के लिए किसी भी बदलाव से अन्यायपूर्ण रूप से दूसरे में बदलाव होता है।जब हमने लिखा Cat.prototype = new Animal()

, हमने एक Cat.prototype

नई वस्तु बनाई । इसके गुणों को बदलते हुए, हमने .prototype

ऑब्जेक्ट कंस्ट्रक्टर फ़ंक्शन के गुणों को प्रभावित नहीं किया।

आइए, मूल वर्ग का एक उदाहरण बनाए बिना - विरासत को लागू करने का प्रयास करें - थोड़ा अलग। आइए बस सुपरक्लास .prototype

से एक .prototype

उपवर्ग में सभी गुणों और विधियों को कॉपी करें । हम समस्या रेखा को इस प्रकार लिखते हैं:

 for (var prop in Animal.prototype){ Cat.prototype[prop] = Animal.prototype[prop]; }

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

आइए निम्न ट्रिकी विधि का सहारा लें: .prototype

उपवर्ग में एक नई वस्तु बनाएं जिसमें .prototype

सुपरक्लास का संदर्भ हो , लेकिन सुपरक्लास का निर्माण कार्य शुरू नहीं करता है। हम जटिल रेखा को फिर से लिखते हैं:

 var Empty = function(){}; //   - Empty.prototype = Animal.prototype; Cat.prototype = new Empty();

हमने Cat.prototype

एक कृत्रिम कक्षा में एक वस्तु बनाई Empty

। जब यह ऑब्जेक्ट बनाया जाता है, तो कुछ भी नहीं होता है क्योंकि कंस्ट्रक्टर फ़ंक्शन Empty()

खाली है। किसी भी असाइनमेंट में Cat.prototype

केवल ऑब्जेक्ट के गुणों में परिवर्तन की चिंता होगी Cat.prototype

और सुपरक्लास के निर्माण कार्य को प्रभावित नहीं करेगा Animal

। यदि दुभाषिया आवश्यक विधि को या तो कक्षा के उदाहरण में Cat

या गुणों में नहीं खोजता है Cat.prototype

, तो यह ऑब्जेक्ट के कंस्ट्रक्टर फ़ंक्शन की ओर मुड़ जाएगा Cat.prototype (== new Empty())

और खोज करना शुरू कर देगा Empty.prototype

, जो सीधे हमारी आवश्यकता को संदर्भित करता हैAnimal.prototype

सुपरक्लास के एक कंस्ट्रक्टर फ़ंक्शन को डुप्लिकेट करने की समस्या का समाधान

हम ऐसा कुछ करना चाहेंगे:

 var Cat = function(name){ Animal.apply(this, arguments); }

यानीउपवर्ग के प्रत्येक नए ऑब्जेक्ट को इनिशियलाइज़ करते समय, ऑब्जेक्ट के संदर्भ में Cat

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

new Cat()

.constructor

.prototype.constructor

Cat.prototype = new Empty()

Cat.prototype

(new Cat()).constructor

Cat.prototype.constructor

(new Empty().constructor)

Empty.prototype.constructor ( == Animal.prototype.constructor)

यानीहमारी संपत्ति .constructor

अब सुपरक्लास के निर्माण कार्य को इंगित करती है, उप-वर्ग को नहीं! हमने इस संपत्ति को गलत तरीके से प्रस्तुत किया। यह सब जानते हुए, अभी हम लिख सकते हैं:

 var Cat = function(name){ this.constructor.apply(this, arguments); }

और कोड की वांछित सार्वभौमिकता प्राप्त करें, लेकिन इस कोड के साथ हम और भी अधिक भ्रम का परिचय देंगे, क्योंकि .constructor

ऑब्जेक्ट को उपवर्ग के कॉन्स्टॉककोर फ़ंक्शन को इंगित करना चाहिए, न कि सुपरक्लास को। इसलिए, इस तरह का दिखावा करें: पिछली समस्या की जगह जिसमें वंशानुक्रम हुआ था, हम निम्नलिखित लिखते हैं:

 var Empty = function(){}; //   - Empty.prototype = Animal.prototype; Cat.prototype = new Empty(); Cat.prototype.constructor = Cat; //     - Cat.superClass = Animal; //    -   ,     - : var Cat = function(name){ Cat.superClass.apply(this, arguments); }

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

 Cat.prototype.cry = function(){ Cat.superClass.prototype.cry.apply(this, arguments); alert('one more cat was born'); }

हम अपने कोड में चीजों को डालेंगे और एक सार्वभौमिक विरासत फ़ंक्शन लिखेंगे। हम इसे .prototype

अंतर्निहित फ़ंक्शन-कंस्ट्रक्टर में लिखते हैं Function

। इस प्रकार, हम सभी संभावित कार्यों के लिए एक नई विधि बनाएंगे, जिसमें शामिल हैं और हमारे कस्टम वर्गों के लिए।

 //    Function.prototype.inheritsFrom = function(superClass) { var Inheritance = function(){}; Inheritance.prototype = superClass.prototype; this.prototype = new Inheritance(); this.prototype.constructor = this; this.superClass = superClass; } // -  var Class = function(){} //      Class.prototype.method = function(){}; // -  var ClassSub = function(){ ClassSub.superClass.apply(this, arguments); } //   ClassSub.inheritsFrom(Class); // sic! //      ClassSub.prototype.method = function(){ ClassSub.superClass.prototype.method.apply(this, arguments); }

जावा स्क्रिप्ट में OOP (5/5): उपयोगी लिंक्स

जावास्क्रिप्ट में निजी सदस्य , डगलस क्रॉकफोर्ड
जावास्क्रिप्ट , डगलस क्रॉकफोर्ड में शास्त्रीय विरासत
जेएस में ओओपी, भाग 1: सार्वजनिक / निजी चर और तरीके , गेविन किस्टनर
जेएस में ओओपी, भाग 2: विरासत , गेविन किस्टनर
जावास्क्रिप्ट में विरासत , केविन लिंडसे
लिटिल जावास्क्रिप्ट चालें, या एक नए तरीके से स्क्रिप्ट लिखें , दिमित्री कोटेरोव
बिग जावास्क्रिप्ट ट्रिक , दिमित्री कोटेरोव
JavaScript ,

जावास्क्रिप्ट में कक्षाएं, वस्तुएं और विरासत