"ฉันคิดว่าจะทำมันทำให้แต่ละ obj ขึ้นอยู่กับอีกอันหนึ่ง"
ดังที่ไคล์อธิบายเมื่อสองวัตถุ[[Prototype]]เชื่อมโยงกันพวกมันไม่ได้ขึ้นอยู่กับกันและกันจริงๆ แทนที่จะเป็นวัตถุแต่ละชิ้น คุณกำลังเชื่อมโยงวัตถุหนึ่งกับอีกชิ้นหนึ่งด้วยการ[[Prototype]]เชื่อมโยงซึ่งคุณสามารถเปลี่ยนแปลงได้ตลอดเวลาที่คุณต้องการ หากคุณใช้[[Prototype]]วัตถุที่เชื่อมโยงสองชิ้นที่สร้างขึ้นผ่านสไตล์ OLOO โดยพึ่งพาซึ่งกันและกันคุณควรคิดเหมือนกันเกี่ยวกับวัตถุที่สร้างขึ้นผ่านการ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();
การตรวจสอบบางอย่าง (หลีกเลี่ยง console.log) -
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-style โดยอ้อมโดยใช้constructor-style
"ตามที่เป็นอยู่ ObjB จะต้องสร้างจาก ObjA .. Object.create (ObjB) เป็นต้น"
ไม่มีObjBที่นี่ไม่เหมือนอินสแตนซ์ (ในภาษาคลาสสิก-based)
ObjAของชั้นใด มันน่าจะพูดได้ว่าเหมือนobjBobject ถูกมอบหมายให้เป็นObjAobject ในตอนที่สร้าง "ถ้าคุณใช้ constructor คุณจะต้องทำ 'coupling' เหมือนกันแม้ว่าจะใช้ประโยชน์ทางอ้อมโดยทางอ้อม.prototypeก็ตาม