जावास्क्रिप्ट में रिकर्सिव प्रोटोटाइप विरासत?

Question

Object.create = function (o) { 
    function F() {} 
    F.prototype = o; 
    return new F(); 
}; 

Prototypal Inheritance in JavaScript

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

a = { 
    foo: [1,2,3] 
} 

b = Object.create(a); 
// b.foo -> [1,2,3] 
b.foo = "test"; 
// b.foo -> "test" 
// a.foo -> [1,2,3] 

c = Object.create(a); 
// c.foo -> [1,2,3] 
c.foo[0] = 'test'; 
// c.foo -> ["test",2,3] 
// a.foo -> ["test",2,3] 

c.foo परिवर्तित करने का प्रयास में मैं a.foo बजाय बदल गया है, c.foo परिवर्तन दिखा है क्योंकि यह a से इनहेरिट है। एकमात्र समाधान मैं अभी देख ही b के प्रत्यक्ष गुण संशोधित करने के लिए है:

d = Object.create(a); 
d.foo = Object.create(a.foo); 
d.foo[0] = 'text'; 

मैं वहाँ एक बेहतर समाधान मैं याद कर रहा हूँ है यकीन है! मैं मूल वस्तुओं को संशोधित करने के जोखिम के बिना पुरानी वस्तुओं से नई वस्तुओं को कैसे बना सकता हूं?

Answer 1

+1 Crockford = डी

मुझे लगता है कि सरणियों हमेशा संदर्भ द्वारा पारित कर रहे हैं, और सरणी की नकल की कभी नहीं रही है संदर्भित करने के लिए। मुझे लगता है कि Array.slice इसे कॉपी करेगा, लेकिन यह एक फ्रिज केस है ...

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

function a() { 
    this.foo = [0, 1, 2]; 
} 

इस तरह, आप हमेशा प्रत्येक कॉल के लिए एक नई सरणी मिल जाएगा। बस बी = नया एक(); यह मेरे लिए काम करता है ...

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

Answer 2

खैर हाँ:

1)

b.foo = "test"; 
// b.foo -> "test" 

"परीक्षण" के साथ एक के अपने F.prototype संदर्भ की जगह ताकि आप कोई त्रुटि देखते हैं, लेकिन वास्तव में यह है 2 बदतर तो)

2)

c = Object.create(a); 
// c.foo -> [1,2,3] 
c.foo[0] = 'test'; 
// c.foo -> ["test",2,3] 
// a.foo -> ["test",2,3] 

c.foo के बाद से एक वस्तु को संशोधित करता है [0] यह करने के लिए & a.foo बिंदु

समाधान here

Answer 3

जब आप एक प्रोटोटाइप कोई नकल किया जाता है से एक नई वस्तु बनाने (वे एक मूल्य के लिए संदर्भ/संकेत दिए गए हैं)।यहां तक ​​कि नहीं संपत्ति की नकल की है:

function F() {} 
F.prototype.a = 1 
new F().hasOwnProperty("a") // => false 
new F().a // => 1 

आप

var f = new F(); 
f.a = 2; 

तो फिर तुम F.protoype में संपत्ति नहीं बदल रहे हैं, तो आप f के लिए एक नया प्रॉपर्टी जोड़ रहे हैं करते हैं:

var f = new F(); 
f.a = 2; 
f.a // => 2; 
delete f.a; 
f.a // => 1 

तो यह आपके द्वारा संपत्ति निर्दिष्ट करने वाले प्रत्येक मूल्य पर लागू होता है।

function F() { 
    this.a = []; 
} 
var f = new F(); 
var g = new F(); 
f.a === g.a // => false 

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

और अगर आप "उपवर्ग" करना चाहते एफ, यह नया निर्माता से कॉल करने के लिए याद रखें:

function F() { this.a = []; } 
function G() { F.call(this); } 
G.prototype = new F(); 

Answer 4

यह वह जगह है समाधान:

Object.create = function (o) { 
    function F() { 
     for(var prop in this) 
      if(o.hasOwnProperty(prop)) 
       this[prop] = Object.create(o[prop]); 
    } 
    F.prototype = o; 
    return new F(); 
}; 

इस समाधान के जनरल प्रतिबंध यह है कि प्रोटोटाइप चाहिए है रिकर्सिव रेफरेंस नहीं है।

इसके अलावा इस समस्या को बिना किसी प्रतिबंध के हल करना संभव है, लेकिन समाधान अधिक जटिल होगा। अनंत रिकर्सिव ऑब्जेक्ट सृजन को रोकने के लिए आप प्रारंभिक प्रक्रिया के दौरान किसी प्रकार के अस्थायी मानचित्र संग्रहण का उपयोग कर सकते हैं। यह भंडारण आरंभिक वस्तुओं के बीच कैश संदर्भ होगा।

Answer 5

मैंने कभी देखा है कि सबसे अच्छा विरासत पैटर्न Google क्लोजर लाइब्रेरी है। यह रचनाकारों पर आधारित है। यहाँ उदाहरण है:

//with this method we will inherit one "class" (there are no real classes in JS) from another. 
var inherit = function (c, p) { 
    function F() {} 
    F.prototype = p.prototype; 
    c.prototype = new F; 
    c.prototype.constructor = c; 
}; 

//create one "class" 
var A = function(){ 
    this.foo = [1,2,3]; 
} 
//create its instance 
var a = new A(); 

//create another "class" 
var C = function(){ 
    //call the parent constructor 
    A.call(this); 
} 
//make inheritance 
inherit(C, A); 
//create example of inherited "class" 
var c = new C(); 

और परिणाम के रूप में आप चाहते हैं:

console.log(c.foo); 
//-> [1,2,3] 
c.foo[0] = 'test'; 
console.log(c.foo); 
//-> ['test',2,3] 
console.log(a.foo); 
//-> [1,2,3]