“我想这样做会使每个 obj 依赖于另一个”
正如 Kyle 所解释的，当两个对象被 [[Prototype]] 链接时，它们并不是真的
相互依赖；相反，它们是单独的对象。你正在链接一个
使用[[Prototype]] 链接反对对方，您可以随时更改。 如果您将通过 OLOO 样式创建的两个 [[Prototype]] 链接对象视为相互依赖，那么您也应该对通过 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, baz bbjects 通过任意对象相互链接
他们的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 风格的对象如何（html，css，js）
对象不同于OLOO 风格的代码？事实上，它们服务于相同的目的。在OLOO 样式中，一个对象委托给Tech（显式设置委托），而在constructor 样式中，一个对象委托给Tech.prototype（隐式设置委托）。最终，您最终将三个相互没有联系的对象链接到一个对象，直接使用OLOO-style，间接使用constructor-style。
“按原样，必须从 ObjA.. Object.create(ObjB) 等创建 ObjB”
不，ObjB 这里不像任何类的实例（在基于经典的语言中）
ObjA。 可以说objB 对象在创建时被委托给ObjA 对象
时间”。如果你使用构造函数，你会做同样的“耦合”，虽然间接地通过使用.prototypes。