“我想这样做会使每个 obj 依赖于另一个”
正如凯尔所解释的,当两个对象被[[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
b/w 后者和前者代码的唯一区别在于,在后一个
foo
, 中bar
,baz
对象通过其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 Objects ( html
, css
, js
) Objects 与OLOO
-style 代码有何不同?事实上,它们的目的是一样的。在OLOO
-style one 对象委托给Tech
(委托被显式设置)而在constructor
-style one 对象委托给Tech.prototype
(委托被隐式设置)。最终,您最终将三个对象(彼此之间没有链接)链接到一个对象,直接使用OLOO
-style,间接使用constructor
-style。
“按原样,ObjB 必须从 ObjA .. Object.create(ObjB) 等创建”
不,ObjB
这里不像任何类的实例(在基于古典的语言中)
ObjA
。应该说对象在创建时objB
被委托给ObjA
对象”。如果您使用构造函数,您会完成相同的“耦合”,尽管是通过使用.prototype
s间接完成的。