दिलचस्प पोस्ट
Android आइकन बनाम लोगो माइक्रोसॉफ्ट जेट वाइल्डकार्ड: तारांकन या प्रतिशत चिन्ह? Django के मॉडल के रूप में आवश्यक फ़ील्ड अजगर में शफल स्ट्रिंग इस variadic टेम्पलेट कोड क्या करता है? MySQL और GROUP_CONCAT () अधिकतम लंबाई "रिक्त या शून्य मान" की जांच करने का सर्वोत्तम तरीका सूची <? MyType फैलता है> इंटरेक्टिव एडिटर के बिना स्वचालित रूप से बैज का उपयोग करके क्रॉन जॉब कैसे बना सकता है? पायथन नॉन-लॉकल स्टेटमेंट जावा में विशेष वर्णों से बचने के लिए यूआरएल कैसे एन्कोड करें रेल 4: उप पथ में नाम मॉडल के बिना रेल मॉडल को व्यवस्थित करें? AngularJS का उपयोग करके आप इनपुट से मूल्य कैसे सीमित कर सकते हैं? मैं PowerShell में स्ट्रिंग और चर को कैसे जोड़ूं? – : जेएसएएन ऑब्जेक्ट्स को भेजा गया अनधिकृत चयनकर्ता

JavaScript प्रोटोटाइप का इस्तेमाल करते हुए कॉलिंग विधि

क्या जावास्क्रिप्ट में मूल विधि को प्रोटोटाइप विधि से कॉल करना संभव है, यदि यह ओवरराइड किया गया है?

MyClass = function(name){ this.name = name; this.do = function() { //do somthing } }; MyClass.prototype.do = function() { if (this.name === 'something') { //do something new } else { //CALL BASE METHOD } }; 

Solutions Collecting From Web of "JavaScript प्रोटोटाइप का इस्तेमाल करते हुए कॉलिंग विधि"

मुझे समझ नहीं आया कि आप वास्तव में क्या करने की कोशिश कर रहे हैं, लेकिन आम तौर पर ऑब्जेक्ट-विशिष्ट व्यवहार को क्रियान्वित करना इन पंक्तियों के साथ किया जाता है:

 function MyClass(name) { this.name = name; } MyClass.prototype.doStuff = function() { // generic behaviour } var myObj = new MyClass('foo'); var myObjSpecial = new MyClass('bar'); myObjSpecial.doStuff = function() { // do specialised stuff // how to call the generic implementation: MyClass.prototype.doStuff.call(this /*, args...*/); } 

यह करने के लिए एक तरह से आधार विधि को बचत होगी और फिर इसे ओवरराइड की विधि से बुलाएगा, जैसे कि

 MyClass.prototype._do_base = MyClass.prototype.do; MyClass.prototype.do = function(){ if (this.name === 'something'){ //do something new }else{ return this._do_base(); } }; 

मुझे डर है कि आपका उदाहरण आपके विचार के अनुसार काम नहीं करता है। यह भाग:

 this.do = function(){ /*do something*/ }; 

की परिभाषा को ओवरराइट करता है

 MyClass.prototype.do = function(){ /*do something else*/ }; 

चूंकि नव निर्मित ऑब्जेक्ट में पहले से ही "डू" प्रॉपर्टी है, इसलिए यह प्रोटोटाइप श्रृंखला नहीं दिखती है।

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

 function my_class(name) { return { name: name, do: function () { /* do something */ } }; } function my_child(name) { var me = my_class(name); var base_do = me.do; me.do = function () { if (this.name === 'something'){ //do something new } else { base_do.call(me); } } return me; } var o = my_child("something"); o.do(); // does something new var u = my_child("something else"); u.do(); // uses base function 

मेरी राय में जावास्क्रिप्ट में ऑब्जेक्ट्स, कन्स्ट्रक्टर और इनहेरिटन्स को संभालने का एक बहुत ही स्पष्ट तरीका है। आप क्रॉकफ़ॉर्ड्स में अधिक पढ़ सकते हैं जावास्क्रिप्ट: अच्छे हिस्से ।

मुझे पता है कि यह पोस्ट 4 साल पहले है, लेकिन मेरी सी # पृष्ठभूमि की वजह से मैं कक्षा के नाम को निर्दिष्ट करने के बजाय बेस क्लास को कॉल करने का एक तरीका तलाश रहा था, बल्कि उप-क्लास पर एक संपत्ति द्वारा इसे प्राप्त करता था। इसलिए क्रिस्टोफ के उत्तर में मेरा एकमात्र परिवर्तन होगा

इस से:

 MyClass.prototype.doStuff.call(this /*, args...*/); 

इसके लिए:

 this.constructor.prototype.doStuff.call(this /*, args...*/); 

यदि आप इस तरह एक फ़ंक्शन परिभाषित करते हैं (OOP का प्रयोग करके)

 function Person(){}; Person.prototype.say = function(message){ console.log(message); } 

एक प्रोटोटाइप फ़ंक्शन कॉल करने के दो तरीके हैं: 1) एक उदाहरण बनाएं और ऑब्जेक्ट फ़ंक्शन कॉल करें:

 var person = new Person(); person.say('hello!'); 

और दूसरी तरफ है … 2) फ़ंक्शन सीधे प्रोटोटाइप से बुला रही है:

 Person.prototype.say('hello there!'); 

एक विकल्प :

 // shape var shape = function(type){ this.type = type; } shape.prototype.display = function(){ console.log(this.type); } // circle var circle = new shape('circle'); // override circle.display = function(a,b){ // call implementation of the super class this.__proto__.display.apply(this,arguments); } 
 निम्नलिखित समाधान है जो मेरे लिए काम किया है  यह Object.getPrototypeOf का उपयोग करता है
 टेस्ट ए एक सुपर है जिसे getName मिला है
 टेस्ट बी एक बच्चा है जो getName को ओवरराइड करता है , लेकिन इसमें भी है
 getBothNames जो कि getName के सुपर संस्करण के साथ-साथ बाल संस्करण को कॉल करता है
 function TestA() { this.count = 1; } TestA.prototype.constructor = TestA; TestA.prototype.getName = function ta_gn() { this.count = 2; return ' TestA.prototype.getName is called **'; }; function TestB() { this.idx = 30; this.count = 10; } TestB.prototype = new TestA(); TestB.prototype.constructor = TestB; TestB.prototype.getName = function tb_gn() { return ' TestB.prototype.getName is called ** '; }; TestB.prototype.getBothNames = function tb_gbn() { return Object.getPrototypeOf(TestB.prototype).getName.call(this) + this.getName() + ' this object is : ' + JSON.stringify(this); }; var tb = new TestB(); console.log(tb.getBothNames()); 
 function NewClass() { var self = this; BaseClass.call(self); // Set base class var baseModify = self.modify; // Get base function self.modify = function () { // Override code here baseModify(); }; } 

अगर मैं सही ढंग से समझता हूं, तो आप चाहते हैं कि बेस फ़ंक्शनैलिटी हमेशा की जानी चाहिए, जबकि इसके एक भाग को लागू करने के लिए छोड़ा जाना चाहिए

आपको ' टेम्पलेट विधि ' डिज़ाइन पैटर्न से मदद मिल सकती है।

 Base = function() {} Base.prototype.do = function() { // .. prologue code this.impldo(); // epilogue code } // note: no impldo implementation for Base! derived = new Base(); derived.impldo = function() { /* do derived things here safely */ } 

यदि आप अपने सुपर वर्ग को नाम से जानते हैं, तो आप ऐसा कुछ कर सकते हैं:

 function Base() { } Base.prototype.foo = function() { console.log('called foo in Base'); } function Sub() { } Sub.prototype = new Base(); Sub.prototype.foo = function() { console.log('called foo in Sub'); Base.prototype.foo.call(this); } var base = new Base(); base.foo(); var sub = new Sub(); sub.foo(); 

यह प्रिंट होगा

 called foo in Base called foo in Sub called foo in Base 

जैसा सोचा था।

Object.getPrototypeOf(this) साथ एक और तरीका है Object.getPrototypeOf(this) का उपयोग करके प्रोटोटाइप श्रृंखला को स्पष्ट रूप से पार करना

 const speaker = { speak: () => console.log('the speaker has spoken') } const announcingSpeaker = Object.create(speaker, { speak: { value: function() { console.log('Attention please!') Object.getPrototypeOf(this).speak() } } }) announcingSpeaker.speak() 

नहीं, आपको कन्स्ट्रक्टर में कार्य करना और प्रोटोटाइप के भिन्न नामों में कार्य करना होगा।

इसके अलावा, यदि आप सभी उदाहरणों को ओवरराइड करना चाहते हैं और केवल एक विशेष उदाहरण नहीं है, तो यह एक मदद कर सकता है।

 function MyClass() {} MyClass.prototype.myMethod = function() { alert( "doing original"); }; MyClass.prototype.myMethod_original = MyClass.prototype.myMethod; MyClass.prototype.myMethod = function() { MyClass.prototype.myMethod_original.call( this ); alert( "doing override"); }; myObj = new MyClass(); myObj.myMethod(); 

परिणाम:

 doing original doing override 
 function MyClass() {} MyClass.prototype.myMethod = function() { alert( "doing original"); }; MyClass.prototype.myMethod_original = MyClass.prototype.myMethod; MyClass.prototype.myMethod = function() { MyClass.prototype.myMethod_original.call( this ); alert( "doing override"); }; myObj = new MyClass(); myObj.myMethod();