"Achei que fazer isso tornaria cada obj dependente um do outro"
Como Kyle explica quando dois objetos estão [[Prototype]]vinculados, eles não são realmente dependentes um do outro; em vez disso, são objetos individuais. Você está ligando um objeto a outro com uma [[Prototype]]ligação que pode ser alterada a qualquer momento que desejar. Se você considerar dois [[Prototype]]objetos vinculados criados por meio do estilo OLOO como sendo dependentes um do outro, também deverá pensar o mesmo sobre os criados por meio de constructorchamadas.
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
Agora pense por um segundo que você pensa foo bare bazcomo sendo dependente um do outro?
Agora vamos fazer o mesmo com 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
A única diferença b / w o último e o primeiro código é que no caso deste último
foo, bar, bazbbjects estão ligados a cada um-a outra através de objectos arbitrários da sua constructorfunção ( Foo.prototype, Bar.prototype, Baz.prototype) mas no ex um ( OLOOestilo) que estão ligadas directamente. Ambas as maneiras que você está apenas ligando foo, bar, bazuns com os outros, diretamente na antiga um e indiretamente no último. Mas, em ambos os casos, os objetos são independentes um do outro porque não é realmente como uma instância de qualquer classe que, uma vez instanciada, não pode ser herdada de alguma outra classe. Você sempre pode alterar qual objeto um objeto deve delegar também.
var anotherObj= {};
Object.setPrototypeOf(foo, anotherObj);
Portanto, são todos independentes uns dos outros.
"Eu esperava OLOOresolver o problema em que cada objeto não sabe nada sobre o outro."
Sim, isso é realmente possível-
Vamos usar Techcomo um objeto utilitário
var Tech= {
tag: "technology",
setName= function(name) {
this.name= name;
}
}
crie quantos objetos desejar 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
Você acha que html, css, jsobjetos estão conectados uns aos-outros? Não, eles não são. Agora vamos ver como poderíamos ter feito isso com a constructorfunção
function Tech() { }
Tech.prototype.tag= "technology";
Tech.prototype.setName= function(name) {
this.name= name;
}
crie quantos objetos desejar vinculados Tech.proptotype-
var html= new Tech(),
css= new Tech(),
js= new Tech();
Algumas verificações (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
Como você acha que esses constructorobjetos -estilo ( html, css, js) Objetos diferente do OLOOcódigo de estilo? Na verdade, eles têm o mesmo propósito. No OLOOestilo, um objeto delega Tech(a delegação foi definida explicitamente), enquanto no constructorestilo um objeto é delegado Tech.prototype(a delegação foi definida implicitamente). No final das contas, você acaba ligando os três objetos, sem ligação entre si, a um objeto, usando diretamente OLOO-style, indiretamente usando constructor-style.
"Como está, ObjB deve ser criado a partir de ObjA .. Object.create (ObjB) etc"
Não, ObjBaqui não é como uma instância (em linguagens clássicas) de qualquer classe
ObjA. Deve-se dizer que o objBobjeto é delegado ao ObjAobjeto no momento de sua criação " . Se você usasse o construtor, teria feito o mesmo 'acoplamento', embora indiretamente usando .prototypes.