5.1 [[Prototype]]
当你试图引用对象的属性时会触发[[Get]]操作，比如myObject.a。对于[[Get]]来说，第一步是检查对象本身是否有这个属性，如果有的话就使用它。
但是如果a 不在myObject中，就需要使用对象的[[Prototype]]链了。
var anotherObject = {
a: 2
}
// 创建一个关联到anotherObject的对象
var myObject = Object.create( anotherObject );
myObject.a; //2
现在myObject对象的[[Prototype]]关联到了anotherObject。如果在anotherObject中也找不到，会继续找下去，直到查找完整条[[Prototype]]链。还是找不到了话会返回 undefined
5.1.1 Object.prototype
[[Prototype]]的尽头便是Object.prototype。由于所有的"普通"对象都“源于”这里，所以它包含JS中许多通用的功能。如.toString() .valueOf() .hasOwnProperty() .isPrototypeOf()等
5.1.2 属性设置和屏蔽
myObject.foo = "bar";
我们分析下如果foo不直接存在于myObject中而是存在于有效值链上层时 myObject.foo == 'bar' 会出现的三种情况。
如果在[[Prototype]]链上层存在名为foo的普通数据访问属性并且没被标记为只读
writable: false，那就会直接在myObject中添加一个名为foo的新属性，它是屏蔽属性。如果在[[Prototype]]链上层存在foo，但是被标记为只读
writable: false，那么无法修改已有属性或者在myObject上创建屏蔽属性。严格模式将抛出错误。如果在[[Prototype]]链上层存在foo并且它是一个setter，那就一定会调用这个setter。foo不会被添加到myObject, 也不会重新定义foo这个setter。
如果你希望在第二种和第三种情况下也屏蔽foo，那就不能使用 = 操作符来赋值，而是使用 Object.defineProperty(), 来向myObect添加foo。
有些情况下会隐式产生屏蔽，一定要当心：
var anotherObject = {
a: 2
};
var myObject = Object.create( anotherObject );
anotherObject.a; //2
myObject.a; // 2
anotherObject.hasOwnProperty("a"); //true
myObject.hasOwnProperty("a"); // false
myObject.a++; // 隐式屏蔽
anotherObject.a; //2
myObject.a; //3
myObject.hasOwnProperty("a"); // true
修改委托属性时一定要小心。如果想让anotherObject.a的值增加，唯一的办法是anotherObject.a++
5.2 类
在JS中，类无法描述对象的行为（因为根本就不存在类）。对象直接定义自己的行为。再说一遍，JS中只有对象。
5.2.1 “类”函数
JS中不好的行为在被滥用，就是模访类。
这种奇怪的“类似类”的行为利用了函数的一种特殊特性：所有的函数默认都会拥有一个名为prototype的公有并不可枚举可属性，它会指向另一个对象：
function Foo(){
//...
}
Foo.prototype; // {}
这个对象到底是什么？
最直接的解释就是，这个对象是在调用new Foo()时创建的，最后会被关联到这个Foo.prototype对象上。
new Foo() 会生成一个新对象，这个新对象的内部链接[[Prototype]]关联的是Foo.prototype对象。
最后我们得到了两个对象，它们之间互相关联，就是这样。
new Foo() 这个函数调用实际上并没有直接创建关联，这个关联只是一个意外的副作用。new Foo()只是间接完成了我们的目标：一个关联到其他对象的新对象。
那么有没有更直接的方法来做到这一点呢？当然！功臣就是Object.create()，我们后面介绍。
“原型继承”是容易混淆的组合术语
继承意味着复制操作，JS（默认）并不会复制对象属性。相反，JS会在两个对象之间创建一个关联，这样一个对象就可通过委托访问另一个对象的属性和函数。委托这个术语可更加准确地描述JS中对象的关联机制。
5.2.2 构造函数
function Foo() {
//...
}
Foo.prototype.constructor === Foo; // true
var a = new Foo();
a.constructor === Foo; // true
Foo.prototype 默认有一个公有且不可枚举的属性 .constructor，这个属性引用的是对象关联的函数。此外，我们可看到通过“构造函数”调用new Foo() 创建的对象也有一个 .constructor 属性，指向 "创建这个对象的函数"
1. 构造函数孩是调用
实际上，Foo和其他函数没有任何区别。函数本身并不是构造函数，然而，当你在调用时，前面加上new 关键字之后，就会被这个函数调用变成一个“构造函数调用”。实际上，new会劫持所有普通函数并用构造对象的形式来调用它。
function NothingSpecial() {
console.log("Don`t mind me!");
}
var a = new NothingSpecial();
// "Don`t mind me!"
a; // {}
NothingSpecial只是一个普通函数，但是使用new调用时，它就会构造一个对象并赋值给a。换句话说，在JS中对于“构造函数”最准确的解释是，所有带new的函数调用。
5.3 （原型）继承
下面代码就是典型的“原型风格”
function Foo(name){
this.name = name;
}
Foo.prototype.myName = function(){
return this.name;
};
function Bar(name, label){
Foo.call(this, name);
this.label = label;
}
// 我们创建了一个新的 Bar.prototype对象并关联到 Foo.prototype
Bar.prototype = Object.create(Foo.prototype);
// 注意！现在没有Bar.prototype.constructor了
// 如果你需要这个属性的话需要手动修复
Bar.prototype.myLabel = function(){
return this.label;
}
var a = new Bar("a", "obj a");
a.myName(); //a
a.myLabel(); //obj a
这段代码核心部分就是 Bar.prototype = Object.create(Foo.prototype)。调用Object.create()会凭空创建一个新对象并把新对象内部的[[Prototype]]关联对你指定的对象（本例是Foo.prototype）。
声明 function Bar() {} 时，和其他函数一样，Bar会有一个 .prototype关联到默认的对象，但是这个对象并不是我们想要的foo.prototype。因此我们创建了一个新对象并把它关联到我们希望的对象上，直接把原始的关联对象抛弃掉。
注意，下面两个常见的错误做法：
// 和你想要的机制不一样
Bar.prototype = Foo.prototype;
// 基本上满足你的需求，但是可能会产生副作用
Bar.prototype = new Foo();
Bar.prototype = Foo.prototype 并不会创建一个关联到Bar.prototype的新对象，它只是让Bar.prototype直接引用Foo.prototype对象。因此当你执行类似Bar.prototype.myLabel = ... 的赋值语句时会直接修改Foo.prototype对象本身。显然这不是你想要结果。
Bar.prototype = new Foo() 的确会创建一个关联到Bar.prototype的新对象。但是它使用了Foo()的“构造函数调用”，如果函数Foo有一些副作用（比如写日志、修改状态、注册到其他对象、给this添加数据属性等）的话， 就会影响到Bar() 的“后代”，后果不堪设想。
因此，要创建一个合适的关联对象，必须使用Object.create()而不是使用具有副作用的Foo()。这样做唯一确定是要抛弃旧对象，不能直接修改已有的默认对象。
ES6添加了辅助函数Object.setPrototypeOf()，可用标准且可靠的方法来修改关联。
// ES6 前
Bar.prototype = Object.create(Foo.prototype);
// ES6
Object.setPrototypeOf( Bar.prototype, Foo.prototype );
检查“类”关系
function Foo() {
//...
}
Foo.prototype.blah = ...;
var a = new Foo();
如果找到a的祖先呢？
第一种方法是站在"类"的角度来判断：
a instanceof foo; //true
instanceof 操作符的左操作数是一个普通对象，右操作数是一个函数。instanceof回答的问题是：在a的整条[[Prototype]]链中是否有指向Foo.prototype的对象？
可惜，这个方法只能处理对象(a)和函数(带 .prototype 引用的 Foo)之间的关系。
如果你想判断两个对象之间是否通过[[Prototype]]链关联，只用 instanceof 无法实现。
第二种判断[[Prototype]]反射的方法，更加简洁：
Foo.prototype.isPrototypeOf(a); // true
isPrototypeOf() 回答的问题是：在a的整条[[Prototype]]链中是否出现过Foo.prototype？
5.4 对象关联
[[Prototype]]机制就是存在于对象中的一个内部链接，它会引用其他对象。
这个链接的作用是：如果在对象上没有找到需要的属性或者方法引用，引擎就会继续在[[Prototype]]关联的对象上进行查找。同理，如果在后者中也没有找到需要的引用就会继续查找它的[[Prototype]]，依此类推，这一系列的链接被称为“原型链”。
5.4.1 创建关联
var foo = {
something() {
console.log("Tell me something good... ");
}
var bar = Object.create(foo);
bar.something(); // Tell me something good...
}
Object.create() 会创建一个新对象(bar)并把它关联到我们指定的对象(foo),这样我们就可充分发挥[[Prototype]]机制的威力（委托）并且避免不必要的麻烦（比如使用new的构造函数调用会生成 .prototype 和 .constructor 引用）
Object.create(null) 会创建一个拥有空[[Prototype]]链接的对象，这个对象无法进行委托。由于没有原型链，所以instanceof操作符无法进行判断，因此总是返回false。这些特殊的空[[Prototype]]对象通常被称作“字典”，它们完全不会受到原型链的干扰，因此非常适合用来存储数据。
我们不需要类来创建两个对象之间的关系，只需要通过委托来关联对象就足够了。而Object.create()不包含任何“类的诡计”，所以它可完美地创建我们想要的关联关系。
5.4.2 关联关系是备用
var anotherObject = {
cool () {
console.log("cool!");
}
};
var myObject = Object.create( anotherObject );
myObject.cool(); // "cool!"
这段代码可正常工作，但会让API变得很“神奇”，对于未来维护你软件的开发者来说这可能不太好理解。
但是你可让你的API设计不那么“神奇”
var anotherObject = {
cool() {
console.log("cool!");
}
};
var myObject = object.create( anotherObject );
myObject.doCool = function(){
this.cool(); // 内部委托！
};
myObject.doCool(); // "cool!"
从内部来说，我们的实现遵循的是委托设计模式，通过[[Prototype]]委托到anotherObject.cool()。
内部委托比起直接委托可让API接口设计更加清晰。
