"मुझे लगा कि यह प्रत्येक obj को दूसरे पर निर्भर करता है"
जैसा कि काइल बताते हैं कि जब दो ऑब्जेक्ट [[Prototype]]जुड़े होते हैं, तो वे वास्तव में एक दूसरे पर निर्भर नहीं होते हैं; इसके बजाय वे व्यक्तिगत वस्तु हैं। आप एक ऑब्जेक्ट को दूसरे से [[Prototype]]लिंक कर रहे हैं जिसे आप अपनी इच्छानुसार कभी भी बदल सकते हैं। यदि आप [[Prototype]]ओएलओओ शैली के माध्यम से बनाई गई दो जुड़ी हुई वस्तुओं को एक दूसरे पर निर्भर होने के रूप में लेते हैं, तो आपको constructorकॉल के माध्यम से बनाई गई चीजों के बारे में भी यही सोचना चाहिए ।
var foo= {},
bar= Object.create(foo),
baz= Object.create(bar);
console.log(Object.getPrototypeOf(foo)) //Object.prototype
console.log(Object.getPrototypeOf(bar)) //foo
console.log(Object.getPrototypeOf(baz)) //bar
अब एक दूसरे के बारे में सोचें जो आप सोचते हैं foo barऔर bazएक-दूसरे पर निर्भर हैं?
चलिए अब ऐसा ही constructorस्टाइल कोड करते हैं-
function Foo() {}
function Bar() {}
function Baz() {}
Bar.prototype= Object.create(Foo);
Baz.prototype= Object.create(Bar);
var foo= new Foo(),
bar= new Bar().
baz= new Baz();
console.log(Object.getPrototypeOf(foo)) //Foo.prototype
console.log(Object.getPrototypeOf(Foo.prototype)) //Object.prototype
console.log(Object.getPrototypeOf(bar)) //Bar.prototype
console.log(Object.getPrototypeOf(Bar.prototype)) //Foo.prototype
console.log(Object.getPrototypeOf(baz)) //Baz.prototype
console.log(Object.getPrototypeOf(Baz.prototype)) //Bar.prototype
फर्क सिर्फ इतना है b / w बाद और पूर्व कोड कि बाद में है
foo, bar, bazbbjects प्रत्येक-दूसरे के लिए उनके के मनमाने ढंग से वस्तुओं के माध्यम से जुड़े हुए हैं constructorसमारोह ( Foo.prototype, Bar.prototype, Baz.prototype) लेकिन पूर्व एक (में OLOOशैली) वे सीधे जुड़े हुए हैं। दोनों तरीकों तुम सिर्फ लिंक कर रहे हैं foo, bar, bazएक दूसरे के साथ, सीधे पूर्व में और परोक्ष रूप से बाद में। लेकिन, दोनों ही मामलों में ऑब्जेक्ट एक-दूसरे से स्वतंत्र होते हैं क्योंकि यह वास्तव में किसी भी वर्ग के उदाहरण की तरह नहीं होता है, जो एक बार तात्कालिक हो जाता है, उसे किसी अन्य वर्ग से विरासत में नहीं बनाया जा सकता है। आप हमेशा बदल सकते हैं कि किसी वस्तु को किस वस्तु को भी सौंपना चाहिए।
var anotherObj= {};
Object.setPrototypeOf(foo, anotherObj);
इसलिए वे सभी एक-दूसरे से स्वतंत्र हैं।
"मैं उम्मीद कर रहा था कि OLOOउस मुद्दे को हल किया जाएगा जिसमें प्रत्येक वस्तु दूसरे के बारे में कुछ नहीं जानती है।"
हाँ, यह वास्तव में संभव है-
आइए Techउपयोगिता वस्तु के रूप में उपयोग करते हैं-
var Tech= {
tag: "technology",
setName= function(name) {
this.name= name;
}
}
जितनी आप चाहते हैं उतनी वस्तुएँ बनाएँ Tech-
var html= Object.create(Tech),
css= Object.create(Tech),
js= Object.create(Tech);
Some checking (avoiding console.log)-
html.isPrototypeOf(css); //false
html.isPrototypeOf(js); //false
css.isPrototypeOf(html); //false
css.isPrototypeOf(js); //false
js.isPrototypeOf(html); //false
js.isPrototypwOf(css); //false
Tech.isPrototypeOf(html); //true
Tech.isPrototypeOf(css); //true
Tech.isPrototypeOf(js); //true
क्या आपको लगता है html, css, jsवस्तुओं प्रत्येक-दूसरे से जुड़े हैं? नहीं, वे नहीं हैं। अब देखते हैं कि हम constructorफ़ंक्शन के साथ कैसे कर सकते हैं-
function Tech() { }
Tech.prototype.tag= "technology";
Tech.prototype.setName= function(name) {
this.name= name;
}
जितनी आप चाहते हैं उतनी वस्तुएँ बनाएँ Tech.proptotype-
var html= new Tech(),
css= new Tech(),
js= new Tech();
कुछ जाँच (कंसोलिंग से बचें) -
html.isPrototypeOf(css); //false
html.isPrototypeOf(js); //false
css.isPrototypeOf(html); //false
css.isPrototypeOf(js); //false
js.isPrototypeOf(html); //false
js.isPrototypeOf(css); //false
Tech.prototype.isPrototypeOf(html); //true
Tech.prototype.isPrototypeOf(css); //true
Tech.prototype.isPrototypeOf(js); //true
आप इन कैसे सोचते हैं constructorशैली ऑब्जेक्ट ( html, css, js) वस्तुओं से अलग OLOOशैली कोड? वास्तव में वे उसी उद्देश्य की सेवा करते हैं। में OLOOशैली से एक के लिए प्रतिनिधि वस्तुओं Tech(प्रतिनिधिमंडल स्पष्ट रूप से सेट किया गया था) थोड़ी देर में constructorशैली से एक के लिए प्रतिनिधि वस्तुओं Tech.prototype(प्रतिनिधिमंडल परोक्ष स्थापित किया गया था)। अंतत: आप तीन वस्तुओं को एक-दूसरे से जोड़ते हुए, एक वस्तु से, सीधे-सीधे, प्रत्यक्ष- OLOOअप्रत्यक्ष रूप से -स्टाइल का उपयोग करते हुए, लिंकिंग को समाप्त करते हैं constructor।
"जैसा है, ObjB को ObjA .. Object.create (ObjB) आदि से बनाना होगा।"
नहीं, ObjBयहाँ किसी भी वर्ग के उदाहरण (शास्त्रीय-आधारित भाषाओं में) की तरह नहीं है
ObjA। यह कहा जाता है कि objBवस्तु को ObjAनिर्माण के समय वस्तु के रूप में प्रत्यायोजित किया जाता है " । यदि आपने कंस्ट्रक्टर का उपयोग किया है, तो आपने समान 'युग्मन' किया होगा, हालांकि अप्रत्यक्ष रूप से .prototypeएस का उपयोग करके ।