第5章-继承

JavaScript提供了一套丰富的代码重用模式。它可以模拟那些基于类的模式，同时可以支持其他更具表现力的模式。我们下面将研究几种最为直接的模式。

伪类 Pseudoclassical

JavaScript的原型存在这许多的矛盾，它不直接让对象从其他对象继承，反而插入了一个多余的间接层：通过构造函数产生对象。
当一个函数对象被创建时，Function构造器产生的函数对象会运行类似这样的一些代码：
this.prototype = {constructor: this};
新函数对象被赋予一个Prototype属性，它的值是一个包含consrtuctor属性且属性值为该新函数的对象。
我们可以定义一个构造器并扩充它的原型

    var Mammal = function(name){
        this.name = name;
    };

    Mammal.prototype.get_name = function(){
        return this.name;
    };

    Mammal.prototype.says = function(){
        return this.saying || '';
    };

    var mymammal = new Mammal('QQQ');
    var name = mymammal.get_name();

    //我们可以构造另一个伪类来继承Mammal，这是通过定义它的constructor函数并替换它的prototype为一个Mammal的实例来实现的：

    var Cat = function(name){
        this.name = name;
        this.saying = 'OW';
    };

    Cat.prototype = new Mammal();

    Cat.prototype.purr = function(n){
        var i, s = '';
        for(i = 0;i < n;i++){
            if(s){
                s += '-';
            }
            s += 'r';
        }
        return s;
    };

    Cat.prototype.get_name = function(){
        return this.says() + ' ' + this.name + ' ' + this.says();
    };

    var myCat = new Cat('XMM');
    var says = myCat.says();    //"OW"
    var myname = myCat.get_name(); //"OW XMM OW"
    var pr = myCat.purr(5);    //"r-r-r-r-r"

这种方法没有私有属性，所有的属性都是公开的，无法访问父类的方法。更糟糕的是，使用构造器函数存在一个严重的危害，如果你在调用构造器函数时忘记了在前面加上new前缀，那么this将不会绑定到一个新对象上。而是绑定到全局对象上

原型 Prototype

让我们先用对象字面量去构造一个有用的对象

    var myMammal = {
        name: 'QQQ',
        get_name: function(){
            return this.name;
        },
        says: function(){
            return this.says || ' ';
        }
    };

    //定制新的实例
    var myCat = Object.create(myMammal);
    myCat.name = 'XMM';
    myCat.says = 'OW';
    myCat.pr = function(n){
        var i, s = '';
        for(i = 0;i < n;i++){
            if(s){
                s += '-';
            }
            s += 'r';
        }
        return s;
    };
    myCat.get_name =  function(){
        return this.says() + ' ' + this.name + ' ' + this.says();
    };

这是一种“差异化继承”。通过定制一个新的对象，我们指明它与所基于的基本对象的区别。

函数化 Function

迄今为止，我们所看到的继承模式的一个弱点就是没办法保护隐私。对象的所有属性都是可见的。我们无法得到私有变量和私有函数。现在，我们有一个更好的选择，那就是应用模块模式
我们从构造一个生成对象的函数开始。我们以小写字母开头，因为它并不需要new前缀。该函数包含4个步骤

【1】创建一个新对象，有很多的方式去创建一个对象，他可以构造一个对象字面量，或者用构造函数，或者使用Object.create()，或者调用一个会返回一个对象的函数。
【2】有选择的定义私有变量和方法
【3】给这个对象扩充方法。这些方法拥有特权去访问参数
【4】返回那个新对象

这里是一个函数化构造器的伪代码模板：

    var constructor = function(spec,my){
        var that,其他私有变量；
        my = my || {};

        把共享的变量和函数添加到my中

        that = 一个新对象

        添加给that的特权方法

        return that;
    };

让我们把这个模式应用到mammal例子里。此处不需要my，所以我们先抛开它，但会使用一个spec对象。

    var mammal = function (spec){
        var that = {};

        that.get_name: function(){
            return this.name;
        };
        that.says: function(){
            return this.says || ' ';
        };

        return that;
    };

    var myMammal = mammal({name: 'Herb'});