构造函数的继承

刚才在看了阮一峰构造函数继承的网络日志后，可以说是茅塞顿开吧，我知道我写的这篇文章肯定没有阮一峰先生的文章那么深刻，如果看到这篇文章的朋友，想要了解JavaScript构造函数的继承，我建以还是去看看阮一峰先生的网络日志吧。至于我为什么要写，我只是为了加深自己的理解。

JavaScript的每一个构造函数都有一个属性叫做prototype（原型）属性，它包含一个对象，所有实例需要共享的方法和属性都在里面，所以那些不需要共享的方法就写在构造函数里就OK了。

好了直接上代码吧

function Person(name) {
        this.name = name;
    }
    Person.prototype.job = 'basketballplayer';
    var kobe = new Person('Kobe Bryant');
    var james = new Person('LeBron James');
    console.log(kobe.job); //basketballplayer
    console.log(james.job); //basketballplayer

借用阮一峰的一句话：由于所有的实例对象共享同一个prototype对象，那么从外界看起来，prototype对象就好像是实例对象的原型，而实例对象则好像"继承"了prototype对象一样。
在这种情况下如果修改 Person.prototype.job的值，则所有的实例对象的值也会发生相应的改变

    Person.prototype.job = 'singer';
    console.log(kobe.job); //singer;
    console.log(james.job); //singer;
    console.log(kobe.job == james.job); //true

这时实例的job属性都指向了一个一个内存地址，即prototype对象，因此提高了效率。
此外还可以用 isProtoTypeof 方法检测prototype和某个实例的关系：

 console.log(Person.prototype.isPrototypeOf(kobe));//true
 console.log(Person.prototype.isPrototypeOf(james));//true

还可以用in来遍历实例的属性和方法：

 for (var prop in kobe) {
       console.log("kobe[" + prop + "]=" + kobe[prop])
    }
    //kobe[name]=Kobe Bryant
    //kobe[job]=singer

好了重点来了，接下来介绍一种我认为最重要的JavaScript构造函数继承：利用空对象作为中介的一种prototype继承。在这个模式之前还有两种：prototype继承和prototype直接继承。

1.prototype继承：
在此前的Person构造函数的基础上我们再创建一个Animals的构造函数

function Animals(){
        this.species = "hunman";
    }
    function Person(name) {
        this.name = name;
    }
    //将Person的原生对象指向一个Animals实例
    Person.prototype = new Animals();
    Person.prototype.constructor = Person; 
    var kobe = new Person('Kobe Bryant');
    console.log(kobe.species);//hunman

单独说明一下上面代码中的Person.prototype.constructor = Person;的由来：

每个原型对象都有一个constructor属性指向它的构造函数，上一行代码会导致Person的原型对象的构造函数属性指向Animals,所以我们需要重新将这个属性指向Person

验证一下：在重新指向Person之前我们添加下面的代码，控制台会显示true

 console.log(Person.prototype.constructor == Animals)//true

2.prototype直接继承：

prototype直接继承指的是将Person的prototype属性直接指向Animals的prototype属性

首先将Animals构造函数改写;接下来就是

 function Animals(){}
    Animals.prototype.species = "hunman";
    function Person(name) {
        this.name = name;
    }
    //将Person的原生对象指向一个Animals的prototype对象
    Person.prototype =  Animals.prototype;
    Person.prototype.constructor = Person; 
    var kobe = new Person('Kobe Bryant');
    console.log(kobe.species);//hunman

直接继承有一个很大的缺点：如果改变Animals的prototype对象，Person的prototype对象也会随之改变，当然也有解决的办法就是：利用空对象作为中介的一种prototype继承
3.利用空对象作为中介的一种prototype继承,先来看代码吧：

    //创建一个空函数
    function F(){}
    function Animals(){}
    Animals.prototype.species = "hunman";
    function Person(name) {
        this.name = name;
    }
    //先将Animals的prototype对象赋值给空函数的原生对象
    F.prototype = Animals.prototype;
    //再将F的原生对象指向一个Person的prototype对象
    Person.prototype = F.prototype;
    Person.prototype.constructor = Person; 
    var kobe = new Person('Kobe Bryant');
    console.log(kobe.species);//hunman

我们将上面的代码封装成一个函数：

    //Parent
    function Animals() {}
    Animals.prototype.species = "hunman";
    //Child
    function Person(name) {
        this.name = name;
    }
    function extend(Child, Parent) {
        var F = function () {};
        F.prototype = Parent.prototype;
        Child.prototype = F.prototype;
        Child.prototype.constructor = Child;
    }
    //调用
    extend (Person,Animals);
    var kobe = new Person('Kobe Bryant');
    console.log(kobe.species); //hunman;