原型与原型链

原型

每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象的内部指针。

实例对象有个属性[prototype]，叫做（__ proto__），实例对象可以通过这个属性访问原型对象上的属性和方法

var M = function (name) {
  this.name = name
}
var o = new M('o')
o.__proto__// 原型对象

原型链

假如我们让原型对象等于另一个类型的实例，此时的原型对象讲包含在一个指向另一个原型的指针，相应的，另一个原型中也包含着一个指向另一个构造函数的指针。这样层层递进，就狗证了实例与原型的链条，就是所谓的原型链。

var M = function (name) {
  this.name = name
}
var o = new M('o')
M.prototype.say=function(){
  console.log(this.name)
}
o.say(); // o
M.__proto__ === Function.prototype; // true
M.prototype.constructor === M; // true

原型链

function Parent() {
  this.name='parent';
  this.home='home';
}
function Child(){
  Parent.call(this)
  this.type = 'chile'
}
var child= new Child();
console.log(child.home); //home

上例中，Child类继承了Parent类，而child是Child类的一个实例，当我们想打印child.home时，首先在对象内部寻找该属性,直至找不到,然后才在该对象的原型(child.prototype)里去找这个属性，Child没有home属性，则从实例的child.proto(指向其构造函数Child.prototype对象)对象中查找，此时,Child中也没有次属性，就再向上一级child.proto.proto也就是Parent的原型对象上找，就找到了Parent上的home属性。

创建对象的方法

1.字面量 
var o1 = {name:'o1'} 
var o2 = new Object({name: 'o2'})
2.显示构造函数 
var M = function(name) {this.name = name}
var o3 = new M('o3')
3.Object.create
var p = {name:'p'}
var o4 = Object.create(p)
o4.__proto__ === p //true

instanceof原理

instanceof

instanceof 运算符用来判断实例对象的proto属性和构造函数的prototype是否是同一个引用。instanceof 主要的实现原理就是只要右边变量的 prototype 在左边变量的原型链上即可。

var M = function(name) {this.name = name}
var o5 = new M('o5')
o5 instanceof M; // true
o5 instanceof Object; // true
o5.__proto__ === M.prototype; // true
M.prototype.__proto__ === Object.prototype; // true
o5.__proto__.constructor === M; // true
o5.__proto__.constructor === Object; // false
// 用constructor 判断构造函数直接生成的实例对象更为严谨。

new一个对象的过程

function M(name) {
  this.name = name
  //return this
}
var m = new M('m1');
console.log(m.name);//m1

1.创建一个新对象
2.this 指向这个新对象
3.执行代码，即对 this 赋值
4.返回 this(若返回值不为对象时)

// 模拟new运算符的工作原理
var new2 = function(fun) {
    var o = Object.create(fun.prototype)
    var k = fun.call(o)
    if(typeof k === 'object') {
        return k;
    } else {
        return o;
    }
}
var o6 = new2(M)
o6.intanceof(M) //true
o6.__proto__.constructor === M //true