क्यों प्रोटोटाइप बदलना पहले बनाई गई वस्तुओं को प्रभावित नहीं करता है?

Question

मैं निम्नलिखित कोड है:

var A = function() {}; 
var a = new A(); 
var b = new A(); 
A.prototype.member1 = 10; 

A.prototype = {} 
var c = new A(); 
console.log(a.member1); 
console.log(a.constructor === b.constructor); 
console.log(a.constructor === c.constructor); 
console.log('---------'); 
console.log(c.member1); 

यह उत्पादन होता है:

10 
true 
false 
--------- 
undefined 
undefined 

a और b के प्रोटोटाइप नहीं बदला है और c एक नया एक था। क्या मैं सही हूं कि यह इस तथ्य के कारण हुआ था कि a.constructorc.constructor के बराबर नहीं है और उनमें से प्रत्येक के पास prototype है? क्या कोई अन्य सर्क हैं जब दो वस्तुओं के निर्माता बराबर नहीं हो सकते हैं?

अतिरिक्त प्रश्न: दो undefined स्ट्रिंग क्यों मुद्रित किए गए थे? (क्रोमियम)

Answer 1

समय आप

var a = new A(); 

मूल रूप से इस काम के लिए किया जाता है कॉल कर रहे हैं:

a.__proto__ = A.prototype; 

तो फिर तुम एक नई वस्तु को A.prototype पुन: असाइन है, तो c अपने रूप {} हो जाता है प्रोटोटाइप। a.__proto__ अभी भी यह की ओर इशारा करते है -

A.prototype = {}; 
var c = new A(); 

हालांकि, इस वर्ष A.prototype वस्तु को नष्ट नहीं करता।

क्या मैं सही हूं कि यह तथ्य इस तथ्य के कारण हुआ था कि एक। कंकस्ट्रक्टर सी। कॉन्स्ट्रास्ट्रक्टर के बराबर नहीं है और उनमें से प्रत्येक का प्रोटोटाइप था?

.constructor मूल रूप से केवल एक सुविधा संपत्ति है। इस पर कोई प्रभाव नहीं पड़ता कि उदाहरण कैसे व्यवहार करते हैं।

अतिरिक्त प्रश्न: दो अपरिभाषित तारों को मुद्रित क्यों किया गया था?

मेरे कंसोल में नहीं, वे नहीं करते! (ओपेरा 12)

Answer 2

जब आप कोई ऑब्जेक्ट बनाते हैं, तो कन्स्ट्रक्टर का प्रोटोटाइप नई ऑब्जेक्ट की __proto__ संपत्ति को असाइन किया जाता है। इसके बाद आप प्रोटोटाइप बदल रहे हैं, लेकिन दो a और b वस्तुओं पहले से ही मूल संदर्भ में ओर इशारा करते हैं:

var a = new A(); 
// a.__proto__ == A.prototype == {} (soon == {member1:10}) 
var b = new A(); 
// b.__proto__ == A.prototype == {} (soon == {member1:10}) 

A.prototype = {} // this changes A.prototype, but not a.__proto__ or b.__proto__ 
var c = new A(); // c.__proto__ = {} 

अपना पहला undefinedc.member1 से है।

A.prototype = {} 

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

Answer 3

जवाब अपने कोड की इस पंक्ति में निहित था स्मृति में उद्देश्य {} है। आपके कन्स्ट्रक्टर के रूप में ए का उपयोग करके कोई भी नई ऑब्जेक्ट्स बनाना इस ब्रांड को नए ऑब्जेक्ट को प्रोटोटाइप के रूप में इंगित करेगा।

हालांकि, OLD PROTOTYPE अभी भी स्मृति में मौजूद है। यह सिर्फ ए हैप्रोटोटाइप अब इसके लिए इंगित नहीं करता है। आपके प्रोटोटाइप संदर्भ को फिर से परिभाषित करने से पहले ए कन्स्ट्रक्टर के रूप में ए का उपयोग करके आप जो भी ऑब्जेक्ट बनाते हैं, वह अभी भी इस पुराने प्रोटोटाइप को प्रोटोटाइप के रूप में इंगित कर रहा है।