"Pensé que hacerlo hace que cada objeto dependa del otro"
Como explica Kyle cuando dos objetos están [[Prototype]]vinculados, en realidad no dependen el uno del otro; en cambio, son objeto individual. Está vinculando un objeto a otro con un [[Prototype]]vínculo que puede cambiar en cualquier momento que desee. Si toma dos [[Prototype]]objetos vinculados creados a través del estilo OLOO como dependientes entre sí, también debe pensar lo mismo sobre los creados a través de constructorllamadas.
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
Ahora piensa por un segundo, ¿piensas foo barybaz como dependientes el uno del otro?
Ahora hagamos lo mismo con este constructorcódigo de estilo.
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
La única diferencia b / w este último y el código anterior es que en este último uno
foo, bar, bazbbjects están vinculados a cada-otra a través de objetos arbitrarios de su constructorfunción ( Foo.prototype, Bar.prototype, Baz.prototype), pero en el anterior ( OLOOestilo) que están vinculados directamente. Ambas formas que sólo va a asociar foo, bar, bazuno con el otro, situado en la anterior e indirectamente en el último. Pero, en ambos casos, los objetos son independientes entre sí porque no es realmente como una instancia de ninguna clase que, una vez instanciada, no se puede hacer heredar de alguna otra clase. Siempre puede cambiar qué objeto debe delegar un objeto también.
var anotherObj= {};
Object.setPrototypeOf(foo, anotherObj);
Entonces todos son independientes entre sí.
"Tenía la esperanza de OLOOresolver el problema en el que cada objeto no sabe nada sobre el otro".
Sí, eso es posible
Usemos Techcomo un objeto de utilidad
var Tech= {
tag: "technology",
setName= function(name) {
this.name= name;
}
}
cree tantos objetos como desee vinculados 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
¿Cree que html, css, jsobjetos están conectados entre sí-? No, no lo son. Ahora veamos cómo pudimos haber hecho eso con la constructorfunción
function Tech() { }
Tech.prototype.tag= "technology";
Tech.prototype.setName= function(name) {
this.name= name;
}
cree tantos objetos como desee vinculados Tech.proptotype-
var html= new Tech(),
css= new Tech(),
js= new Tech();
Algunas comprobaciones (evitando 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
¿Cómo cree que estas constructoral estilo de objetos ( html, css, js) objetos difieren del OLOOcódigo de estilo? De hecho, tienen el mismo propósito. En el OLOOestilo uno los objetos delegan a Tech(la delegación se estableció explícitamente) mientras que en el constructorestilo uno los objetos delegan a Tech.prototype(la delegación se estableció implícitamente). En última instancia, termina vinculando los tres objetos, sin ningún vínculo entre sí, con un objeto, usando directamente OLOO-style, indirectamente usando constructor-style.
"Tal como está, ObjB debe crearse desde ObjA .. Object.create (ObjB), etc."
No, ObjBaquí no es como una instancia (en lenguajes de base clásica) de ninguna clase
ObjA. Debería decirse que el objBobjeto se hace delegado a ObjAobjeto en el momento de su creación " . Si hubiera usado el constructor, habría hecho el mismo 'acoplamiento', aunque indirectamente haciendo uso de .prototypes.