„Pomyślałem, że to sprawia, że każdy obiekt jest zależny od drugiego”
Jak wyjaśnia Kyle, kiedy dwa obiekty są [[Prototype]]połączone, w rzeczywistości nie są one od siebie zależne; zamiast tego są indywidualnym przedmiotem. Łączysz jeden obiekt z drugim za pomocą [[Prototype]]powiązania, które możesz zmienić w dowolnym momencie. Jeśli weźmiesz dwa [[Prototype]]połączone obiekty utworzone w stylu OLOO jako zależne od siebie, powinieneś również pomyśleć to samo o tych utworzonych przez constructorwywołania.
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
A teraz pomyśl przez chwilę, o czym myślisz foo baribaz jako zależne od siebie, nawzajem?
Zróbmy teraz ten sam constructorkod stylu-
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
Jedyna różnica b / w drugi i były kodu jest, że w tym ostatnim
foo, bar, bazbbjects są połączone ze sobą, drugi przez dowolnych obiektów ich constructorfunkcji ( Foo.prototype, Bar.prototype, Baz.prototype), ale w pierwszej z nich ( OLOOstylu) są bezpośrednio połączone. Oba sposoby jesteś po prostu łączące foo, bar, bazze sobą, bezpośrednio w dawnym jednym i pośrednio w tym ostatnim. Ale w obu przypadkach obiekty są od siebie niezależne, ponieważ w rzeczywistości nie jest to instancja żadnej klasy, która po utworzeniu instancji nie może dziedziczyć po innej klasie. Zawsze możesz zmienić obiekt, który obiekt powinien również delegować.
var anotherObj= {};
Object.setPrototypeOf(foo, anotherObj);
Więc wszystkie są od siebie niezależne.
„Miałem nadzieję, OLOOże rozwiążę problem, w którym każdy obiekt nic nie wie o drugim”.
Tak, to rzeczywiście możliwe-
Użyjmy Techjako obiektu użytkowego-
var Tech= {
tag: "technology",
setName= function(name) {
this.name= name;
}
}
utwórz tyle obiektów, ile chcesz, aby były połączone 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
Czy uważasz html, css, jsobiekty są połączone ze sobą, inne? Nie, nie są. Zobaczmy teraz, jak mogliśmy to zrobić za pomocą constructorfunkcji-
function Tech() { }
Tech.prototype.tag= "technology";
Tech.prototype.setName= function(name) {
this.name= name;
}
utwórz tyle obiektów, ile chcesz, aby były połączone Tech.proptotype-
var html= new Tech(),
css= new Tech(),
js= new Tech();
Trochę sprawdzania (unikanie 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
Jak myślisz, jak te constructor-Style Objects ( html, css, js) Przedmioty różnią się od OLOOkodu -Style? W rzeczywistości służą temu samemu celowi. W OLOOstylu Techdelegacja jednego obiektu do (delegacja została ustawiona jawnie), podczas gdy delegacja constructorjednego obiektu w stylu Tech.prototype(delegacja została ustawiona niejawnie). Ostatecznie łączysz te trzy obiekty, nie mając żadnego połączenia między sobą, z jednym obiektem, bezpośrednio używając OLOOstylu -styl, pośrednio constructor-styl.
„Tak jak jest, ObjB musi zostać utworzony z ObjA .. Object.create (ObjB) etc”
Nie, ObjBtutaj nie jest przykładem (w językach klasycznych) żadnej klasy
ObjA. Można by powiedzieć, że objBobiekt jest delegowany na ObjAobiekt w czasie jego tworzenia . ” Gdybyś użył konstruktora, zrobiłbyś to samo„ sprzęganie ”, chociaż pośrednio, używając .prototypes.