面试中经常使用的__proto__,prototype和原型链，你都了解了吗？

上一篇随笔主要讲了变量提高的问题，今天咱们来说讲不少前端er在初期很长一段时间内都没有彻底搞明白的原型链和构造函数。

1，什么是构造函数

　　那么要讲到构造函数，必需要有一个函数，因此咱们创建一个函数

　　　　

function Person(){}

　ok，既然是构造函数，那么久要有参数和返回值　

Person = function(name,age,force){

          this.name = name;
          this.age = age;    
          this.force = force;
}

　一个函数就出来了,接下来咱们来看一下这个Person的__proto__和prototype

Person.prototype    //Object {constructor:function(name,age,force),__proto__:Object}

Person.__proto__ //function(){}

　　好的，咱们的构造函数完成了，如今咱们来经过构造函数建立一个对象

var mike = new Person('mike',23,'strong');
mike  //Person {name: "mike", age: 23, force: "strong"}
mike.prototpe  //undefined
mike.__proto__  //Object {constructor:function(name,age,force),__proto__:Object}

　　在上面2段代码，咱们能够发现不少，仔细观看mike.__proto__和Person.prototype，是否是发现，这二者实际上是一个东西，咱们待会验证一下，而且发现mike.prototype是undefined

alert(mike.__proto__ === Person.prototype)    //true

　　这样咱们大概就了解了，构造函数new Person()发生时候的一个过程

　　建立mike对象;

　　mike.__proto__ = Person.prototype;　　

　　Person.call(mike,'mike',23,'strong');

2,__proto__和prototype

　　__proto__按照定义来说，是对象自带的一个属性，这个__proto__它自己又是一个对象，__proto__的属性，能够被mike读取到，但不会显示在mike对象里，固然__proto__对象中的属性读取优先级要低于mike自己

　　而prototype呢，则是函数的一个自带属性，其中prototype又有两个元素，1,constructor指向函数自己，2,__proto__同对象中的__proto__

　　构造函数在建立对象是最大的特色就是会把自身的prototype按值传递给被构造对象的__proto__，由于prototype能够当作对象来看，因此是按引用传递//纠正上次的一个错误

　　暂时我知道的prototype的做用，就是在构造对象时，将自身的prototype（引用）传递给新函数的__proto__

3，原型链

　　这里我能够举个例子

1 mike    //Person {name: "mike", age: 23, force: "strong"};
2 mike.__proto__face = 'handsome';
3 mike    //Person {name: "mike", age: 23, force: "strong"}
4 mike.face    //'handsome'

　　mike对象中没有face属性，因此往mike.__proto__中找face，找到了，显示出来，找不到的话，往mike.__proto__.__proto__中找face，如此往复，直到某一个__proto__返回null

4，屡次继承

　　

function One(){
    this.sayOne = function(){
        alert('nameOne');     
     }
}
function    Two(){};
Two.prototype = new One();
Two.prototype.sayTwo = function(){
    alert('nameTwo');
}
var say = new Two();
say.sayOne()    //‘nameOne’
say.sayTwo()    //‘nameTwo’
two.prototype　　//one(sayOne:function(){},sayTwo:function(){})

　　

　　原理很简单 Two.prototype = new One(); 这一步获得 Two.prototype.__proto__ = One.prototype;

　　say.__proto__ = Two.prototype;

　　因此say.__proto__.__proto__ = One.prototype;

　　因此say.sayTwo = say.__proto__.sayTwo = Two.prototype.sayTwo ;

　　　　One.call(Two.prototype);

　　　　say.sayOne = say.__proto__.sayTwo = Two.prototype.sayOne;

　　要完成屡次继承，只要将上一层的属性实例化到下一层的prototype便可，由于prototype是能够做为对象的__proto__直接使用的！