"Saya pikir untuk melakukannya membuat setiap obyek bergantung pada yang lain"
Seperti yang dijelaskan Kyle saat dua objek [[Prototype]]dihubungkan, keduanya tidak benar-benar bergantung satu sama lain; sebaliknya mereka adalah objek individu. Anda menautkan satu objek ke objek lainnya dengan [[Prototype]]tautan yang dapat Anda ubah kapan saja Anda mau. Jika Anda menganggap dua [[Prototype]]objek tertaut yang dibuat melalui gaya OLOO saling bergantung, Anda juga harus berpikiran sama tentang objek yang dibuat melalui constructorpanggilan.
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
Sekarang pikirkan sejenak apakah Anda memikirkan foo bardanbaz bergantung satu sama lain?
Sekarang mari lakukan hal yang sama constructordengan kode gaya ini-
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
Satu-satunya perbedaan b / w yang terakhir dan mantan kode adalah bahwa dalam satu terakhir
foo, bar, bazbbjects dihubungkan satu sama-lain melalui objek sewenang-wenang dari mereka constructorfungsi ( Foo.prototype, Bar.prototype, Baz.prototype) tapi di bekas satu ( OLOOgaya) mereka terkait langsung. Kedua cara Anda hanya menghubungkan foo, bar, bazsatu sama lain, langsung di bekas satu dan tidak langsung dalam satu terakhir. Namun, dalam kedua kasus, objek tidak bergantung satu sama lain karena tidak benar-benar seperti instance dari kelas mana pun yang pernah dibuat instance-nya, tidak dapat dibuat untuk mewarisi dari kelas lain. Anda selalu dapat mengubah objek mana yang harus didelegasikan oleh objek juga.
var anotherObj= {};
Object.setPrototypeOf(foo, anotherObj);
Jadi mereka semua tidak bergantung satu sama lain.
"Saya berharap OLOOakan menyelesaikan masalah di mana setiap objek tidak tahu apa-apa tentang yang lain."
Ya itu memang mungkin-
Mari kita gunakan Techsebagai objek utilitas-
var Tech= {
tag: "technology",
setName= function(name) {
this.name= name;
}
}
buat objek sebanyak yang Anda ingin ditautkan 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
Apakah Anda berpikir html, css, jsobjek yang terhubung satu sama-lain? Tidak, mereka tidak. Sekarang mari kita lihat bagaimana kita bisa melakukannya dengan constructorfungsi-
function Tech() { }
Tech.prototype.tag= "technology";
Tech.prototype.setName= function(name) {
this.name= name;
}
buat objek sebanyak yang Anda ingin ditautkan Tech.proptotype-
var html= new Tech(),
css= new Tech(),
js= new Tech();
Beberapa pemeriksaan (menghindari 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
Bagaimana Anda pikir ini constructorObjects -gaya ( html, css, js) Objek berbeda dari OLOOkode-gaya? Sebenarnya mereka melayani tujuan yang sama. Dalam- OLOOgaya satu objek didelegasikan ke Tech(delegasi ditetapkan secara eksplisit) sedangkan dalam constructorgaya satu objek didelegasikan ke Tech.prototype(delegasi ditetapkan secara implisit). Pada akhirnya Anda akan menghubungkan ketiga objek, yang tidak memiliki keterkaitan satu sama lain, ke satu objek, secara langsung menggunakan OLOO-style, secara tidak langsung menggunakan constructor-style.
"Sebagaimana adanya, ObjB harus dibuat dari ObjA .. Object.create (ObjB) dll"
Tidak, di ObjBsini tidak seperti instance (dalam bahasa berbasis klasik) dari kelas mana pun
ObjA. Ini bisa dikatakan seperti objBobjek dibuat delegasi ke ObjAobjek pada waktu pembuatannya " . Jika Anda menggunakan konstruktor, Anda akan melakukan 'penggandengan' yang sama, meskipun secara tidak langsung dengan menggunakan .prototypes.