"Я решил, что это делает каждый объект зависимым от другого"
Как объясняет Кайл, когда два объекта [[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
Единственное различие ч / б последнего и бывший код является то , что в последнем одном
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-Style объектов ( html, css, js) объекты отличаются от OLOO-style коды? Фактически они служат той же цели. В OLOO-стиле один объект делегирует объект Tech(делегирование было задано явно), в то время как в constructor-стиле один объект делегирует ему Tech.prototype(делегирование было установлено неявно). В конечном итоге вы связываете три объекта, не имеющие связи друг с другом, с одним объектом, напрямую используя OLOO-style, косвенно используя constructor-style.
«Как есть, ObjB должен быть создан из ObjA .. Object.create (ObjB) и т. Д.»
Нет, ObjBздесь не похоже на экземпляр (в классических языках) какого-либо класса
ObjA. Можно сказать, что objBобъект становится делегатом ObjAобъекта во время его создания " . Если бы вы использовали конструктор, вы бы сделали то же самое« соединение », хотя и косвенно, используя .prototypes.