"Ho pensato che questo rendesse ogni oggetto dipendente dall'altro"
Come spiega Kyle, quando due oggetti sono [[Prototype]]collegati, non sono realmente dipendenti l'uno dall'altro; invece sono oggetti individuali. Stai collegando un oggetto all'altro con un [[Prototype]]collegamento che puoi modificare ogni volta che lo desideri. Se prendi due [[Prototype]]oggetti collegati creati tramite lo stile OLOO come dipendenti l'uno dall'altro, dovresti anche pensare lo stesso a quelli creati tramite le constructorchiamate.
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
Ora pensa per un secondo pensi a foo barebaz come dipendenti l'uno dall'altro?
Ora facciamo lo stesso questo constructorcodice di stile-
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
L'unica differenza b / w quest'ultimo e il primo codice è che in quest'ultimo
foo, bar, bazbbjects sono collegate fra di loro attraverso oggetti arbitrari della loro constructorfunzione ( Foo.prototype, Bar.prototype, Baz.prototype) ma in quella precedente ( OLOOstile) sono legati direttamente. Entrambi i modi si sta solo collegamento foo, bar, bazcon l'altro, proprio di quella precedente e, indirettamente, nel secondo quella. Ma in entrambi i casi gli oggetti sono indipendenti l'uno dall'altro perché in realtà non è come un'istanza di una classe che, una volta istanziata, non può essere fatta ereditare da un'altra classe. Puoi sempre modificare anche l'oggetto che un oggetto deve delegare.
var anotherObj= {};
Object.setPrototypeOf(foo, anotherObj);
Quindi sono tutti indipendenti l'uno dall'altro.
"Speravo OLOOche risolvesse il problema in cui ogni oggetto non sa nulla dell'altro."
Sì, è davvero possibile
Usiamo Techcome oggetto di utilità-
var Tech= {
tag: "technology",
setName= function(name) {
this.name= name;
}
}
crea tutti gli oggetti che desideri collegati a 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
Pensi html, css, jsgli oggetti sono collegati fra di loro? No, non lo sono. Ora vediamo come avremmo potuto farlo con la constructorfunzione-
function Tech() { }
Tech.prototype.tag= "technology";
Tech.prototype.setName= function(name) {
this.name= name;
}
crea tutti gli oggetti che desideri collegati a Tech.proptotype-
var html= new Tech(),
css= new Tech(),
js= new Tech();
Alcuni controlli (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
Come pensi che questi constructoroggetti -style ( html, css, js) oggetti differiscono dal OLOOCodice in stile? In effetti servono allo stesso scopo. In OLOOuno stile gli oggetti delegano a Tech(la delega era impostata esplicitamente) mentre in constructoruno stile gli oggetti delegano a Tech.prototype(la delega era impostata in modo implicito). Alla fine si finisce per collegare i tre oggetti, non avendo alcun collegamento tra loro, a un oggetto, usando direttamente OLOO-style, usando indirettamente constructor-style.
"Così com'è, ObjB deve essere creato da ObjA .. Object.create (ObjB) ecc"
No, ObjBqui non è come un'istanza (nei linguaggi classici) di nessuna classe
ObjA. Si potrebbe dire che l' objBoggetto viene reso delegato ObjAall'oggetto al momento della sua creazione " . Se avessi usato il costruttore, avresti fatto lo stesso" accoppiamento ", sebbene indirettamente utilizzando .prototypes.