1、原型
[[prototype]]
js中的对象有一个特殊的[[prototype]]内置属性，其实就是对于其他对象的引用，几乎所有的对象在创建时[[prototype]]属性都会被赋予一个非空的值
使用for..in和in操作符都会查找对象的整条原型链
所有普通的[[prototype]]链最终都会指向内置的Object.prototype
2、属性设置与屏蔽
myobject.foo = "bar"
1)如果myobject对象中包含名为foo的普通数据访问属性，这条赋值语句只会修改已有的属性值
2）如果foo不是直接存在于myobject中，[[prototype]]链就会发生遍历，类似[[get]]操作，如果原型链上找不到foo，foo就会直接添加到myobject上
3）如果属性名foo又存在于myobject又出现在[[prototype]]链上层，那么就会发生屏蔽。myobject中包含的foo属性会屏蔽原型链上层的所有foo属性，因为myobject.foo总是会选择原型链中最底层的foo属性
分析一下foo不直接存在于myobject而是存在于原型链上层时myobject.foo = ‘bar‘会出现三种情况
1、如果在[[prototype]]上层存在名为foo的普通数据访问属性，并且没有被标记为只读（writable:false）那就会直接在myobject中添加一个名为foo的新属性它是屏蔽属性
2、如果在[[prototype]]上层存在foo但是被标记为只读，那么无法修改已有属性或者在myobject上创建屏蔽属性，如果运行在严格模式下代码会抛出一个错误
3、如果在[[prototype]]链上层存在foo并且它是一个setter那就一定会调用这个setter，foo不会被添加到mtobject
如果你希望第二种、第三种情况也能屏蔽foo就不能使用=操作符来赋值，而是使用Object.defineProperty(...)来向myobject添加foo
3、“类”函数
所有函数都会拥有一个公用并且不可枚举的属性，会指向另一个对象
function Foo() { //... } var a = new Foo(); object.getPropertyOf(a) === Foo.prototype;
调用Foo()时会创建a，其中一步就是将a内部的[[prototype]]链接到Foo.prototype所指向的对象
new Foo()会生成一个新对象（我们称为a）这个新对象的内部链接[[prototype]]关联的是Foo.prototype对象
new Foo()只是间接完成了我们的目标：一个关联到其他对象的新对象
更直接的方法就是Object.create()
4、关于名称
继承意味着复制操作，js并不会复制对象的属性，相反js会在两个对象之间创建一个关联，这样一个对象就可以通过委托访问另一个对象的属性和函数
5、”构造函数“
function Foo() { //... } Foo.prototype.constructor === Foo;//true var a = new Foo(); a.constructor === Foo;//true
实际上a本身并没有.constructor属性。
实际上.constructor引用同样被委托给了Foo.prototype
而Foo.prototype.constructor 默认指向Foo
Foo.prototype的constructor属性只是Foo函数在声明时的默认属性，如果你创建了一个对象并替换了函数默认的prototype对象引用，那么新对象并不会自动获得.constructor属性
修复.constructor需要很多手动操作，方法：记住：constructor并不代表被构造
6、构造函数还是调用
实际上Foo函数本身并不是构造函数，然而当你在普通的函数调用前面加上new关键字调用后，就会把这个函数调用变成构造函数调用。
实际上new会劫持所有普通函数并用构造函数的形式来调用它
function nothing(){ console.log(‘aaa‘); } var a = new nothing();//"aaa" a;//{}
nothing只是一个普通的函数，但是使用new调用时，它就会构造一个对象并赋给a，这看起来像是new的一个副作用
js中对于构造函数最准确地解释是，所有带new的函数调用
函数不是构造函数，当且仅当使用new时，函数会变成构造函数调用
7、（原型）继承
原型风格代码：
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.prrototype.myLabel = function() { return this.label; } var a = new Bar("a","obj a") a.myName(); a.myLabel()
这段代码核心
Bar.prototype = Object.create(Foo.prototype);
调用Object.create()会凭空创建一个“新”对象并把新对象内部的[[Prototype]]关联到指定的对象
换句话说意思是：“创建一个新的Bar.prototype对象并把它关联到Foo.prototype”
下面这两种方式是常见的错误做法：
// 和你想要的机制不一样 Bar.prototype = Foo.prototype; // 基本上满足你的需求，但是可能会产生一些副作用 Bar.prototype = new Foo();
Bar.prototype = Foo.prototype;并不会创建一个关联到Bar.prototype的新对象，只是会让Bar.prototype直接引用Foo.prototype,当执行Bar.prrototype.myLabel的赋值语句时会直接修改Foo.prototype本身
修改对象的[[prototype]]关联方法：
//ES6之前需要抛弃默认的Bar.prototype Bar.prototype = Object.create(Foo.prototype); // ES6开始可以直接修改现有的Bar.prototype Object.setPrototypeOf(Bar.prototype,Foo.prototype)
Object.create（。。。）需要创建一个新对象然后把旧对象抛弃掉，不能直接修改已有的默认对象
如果忽略掉Object.create（）方法带来的轻微性能损失（抛弃的对象需要进行垃圾回收）
8、检查类关系
假设有对象a，如何寻找对象a委托的对象（如果存在的话）
在传统的面向类的环境中，检查一个实例的继承祖先通常被称为内省（或者反射）
function Foo() { // } Foo.prototype.blah = ...; var a = new Foo();
如何通过内省找出a的“祖先”（委托关联）？
方法一：站在类的角度判断
a intanceof Foo;//true
intanceof操作符的左操作数是一个普通的对象，右操作数是一个函数。
intanceof回答的问题是：在a的整条[[Prototype]]链中是否有指向Foo.prototype的对象
可是这个方法只能处理对象（a）和函数（带.prototype引用的Foo）如果你想判断两个对象之间是否通过[[Prototype]]链关联，只用instanceof无法实现
方法二：判断[[Prototype]]反射的方法：
Foo.prototype.isPrototypeOf(a);//true
isPrototypeOf(...)回答的问题是：在a的整条[[Prototype]]链中是否出现过Foo.prototype
// 非常简单:b是否出现在c的[[Prototype]]链中 b.isPrototypeOf(c)
直接获取一个对象的[[Prototype]]链
ES5中：
Object.getPropertyOf(a)
可以验证一下，这个对象引用是否和我们想的一样
Object.getPropertyOf(a) === Foo.prototype;//true
绝大多数（不是所有！）浏览器也支持一种非标准的方法来访问内部[[Prototype]]属性
a.__proto__ === Foo.prototype;//true
这个奇怪的__proto__属性“神奇的”引用了内部的[[Prototype]]对象，如果你想直接查找（甚至可以通过.__proto__.__proto__...来遍历）原型链的话，这个方法非常有用
9、对象关联
1）创建关联
var foo = { something: function() { console.log(‘tell me something good‘); } }; var bar = Object.create(foo); bar.something();//tell me something good
Object.create（）会创建一个新对象（bar）并且把它关联到我们制定的对象foo，这样可以充分发挥[[prototype]]机制的威力（委托）而且避免不必要的麻烦
2）内部委托比直接委托可以可以让API接口设计更加清晰
直接委托：
var anotherObject = { cool:function() { console.log("cool"); } } var myObject = Object.create(anotherObject); myObject.cool();
内部委托：
var anotherObject = { cool:function() { console.log("cool"); } } var myObject = Object.create(anotherObject); myObject.docool = function(){ this.cool();//内部委托 } myObject.docool()//‘cool‘
如果访问对象中并不存在的一个属性，[[Get]]操作就会查找对象内部[[Prototype]]关联的对象。这个关联关系实际上定义了一条原型链（有点像嵌套的作用域链），在查找属性时会对他进行遍历
虽然这些js机制和传统的面向类语言中的“类初始化”，“类继承”很相似，但是js中的机制有一个核心区别，就是不会复制，对象之间是通过内部的[[Prototype]]链关联的
对象之间的关系不是复制而是委托。