Javascript 设计模式读书笔记(三)——继承

摘要：的继承方式属于原型式继承，非常灵活。当使用关键字执行类的构造函数时，系统首先创建一个新对象，这个对象会继承自构造函数的原型对象新对象的原型就是构造函数的属性。也就是说，构造函数用来对生成的新对象进行一些处理，使这个新对象具有某些特定的属性。

继承这个东西在Javascript中尤其复杂，我掌握得也不好，找工作面试的时候在这个问题上栽过跟头。Javascript的继承方式属于原型式继承，非常灵活。因此Javascript的继承方式除了基于类的继承之外还有基于原型的原型式继承。

看了这个词的第一反应我联想到了财产继承，在一般情况下，父母的遗产由子女继承，也就是说子女将会获得财产的使用权。而Javascript中的继承与现实生活中的财产继承还是有区别的。首先，Javascript中的父类和子类可以同时并存，而遗产么，什么样的财产叫遗产呢？其次，财产是花了就没了，而JS里的继承则是子类能够继承父类的方法，可以重复使用，减少代码量。当几个类都需要一个相似的方法时，使用继承可以从同一个类中继承相同的方法，而不用对每个类重复地复制粘贴了。

不用在定义上纠缠过久，下面讨论一下实现继承的一些方法。

开头便说到了JS的继承方式分为基于类的继承（简称类式继承）和基于原型链的继承（简称原型式继承）。

类式继承的特点就是使用函数声明类，通过new关键字创建实例。

创建类的方法很简单，一般可以写成这样：

function Blog(address) {
  this.address = address;
}

Blog.prototype.getAddress = function() {
  return this.address;
}

创建该类的实例通过new关键字即可：

var blog = new Blog("classicemi.github.io");
blog.getAddress(); // "classicemi.github.io"

当使用new关键字时，它和通过一般方式执行函数的区别在于函数的执行方式会改变。当使用new关键字执行Blog类的构造函数时，系统首先创建一个新对象，这个对象会继承自构造函数Blog的原型对象（新对象的原型就是构造函数的prototype属性）。再将this关键字绑定到新对象上，再返回该新对象。也就是说，构造函数用来对生成的新对象进行一些处理，使这个新对象具有某些特定的属性。

创建一个继承Blog的类就需要手工完成和new运算符相似的工作了。

function MyBlog(address, author) {
  Blog.call(this, address);
  this.author = author;
}

当通过new关键字调用MyBlog构造函数时，系统会创建一个新对象（这步是自动的，this即为这个新对象），然后在this上调用超类Blog的构造函数，再给this添加一些MyBlog类特有的不是继承自Blog类的属性，最后将新对象this返回（这步也是自动的）。

下面为了继承Blog类的方法，需要设置原型链，使MyBlog类能够在原型链上找到继承自Blog类的方法。

MyBlog.prototype = new Blog(); // MyBlog类的原型是Blog类的一个实例
MyBlog.prototype.constructor = MyBlog; // 上一步执行后prototype的constructor属性会变成Blog，需要修改回来
MyBlog.prototype.getAuthor = function() { // 给MyBlog添加自己的方法
  return this.author;
}

通过这些操作后，MyBlog类就声明好了，它继承了Blog类的属性和方法，创建MyBlog类实例的方法和创建Blog类实例的方法一样，直接使用new关键字调用构造函数即可。

之前的类式继承是为了模仿其他一些面向对象语言的特点而创造的，并没有真正体现Javascript语言本身的特点，下面要说的原型式继承则是利用JS的原型特性而实现的继承方式。

使用原型式继承时，不需要像类式继承一样用一个类（构造函数）来定义对象的结构，而可以用对象字面量的方式直接创建一个对象，这个对象是作为原型存在的，被称作原型对象(prototype object)。就像工厂生产车间里的模具一样，为以后生产出的零件提供了参考原型。

还是以之前的Blog和MyBlog类为例：

// Blog原型对象
var Blog = {
  address: "classicemi.github.io", // 属性只是作为默认值，一般都会被改写
  getAddress: function() {
    return this.address;
  }
};

这里没有像用一个构造函数来定义Blog类的结构，将方法添加在Blog.prototype上。这里定义的Blog对象只是作为原型存在，为继承Blog类的对象提供一些方法。

现在原型对象有了，要创建继承该原型对象对应的类的新类应该怎么做呢？利用JS的原型链特性，只要将新类的原型设为该原型对象即可。按照这种思路可以写出子类MyBlog的创建方法：

function MyBlogConstrucFunc() {}
MyBlogConstrucFunc.prototype = Blog;
var MyBlog = new MyBlogConstrucFunc();

通过new运算符调用MyBlogConstrucFunc函数，返回的是一个空对象，这个空对象的prototype属性指向原型对象Blog。在返回的空对象中，还可以添加MyBlog类自有的属性和方法。

不过通过这三行代码实现子类对超类的继承还是有些冗余，我们可以实现一个方法来实现对超类的继承，将超类作为该方法的参数传入并在最后将空对象返回即可。

function clone(object) {
  function F() {}
  F.prototype = object;
  return new F();
}

以上所讨论的是比较严格的继承方式，有的时候，我们可能只想对某个函数进行重用，并不需要完全的继承，那么我们可以将函数以扩充的方式在类之间进行共享。对于重用频率比较高的方法，我们可以将它们归并在一个类中，然后用这个类去扩充其他的类。这种方法称为掺元类（mixin class）。这种处理方法在很多JS库（比如jQuery和Underscore）中都有用到，是一种扩充工具函数的好方法。

var Mixin = function() {}
Mixin.prototype = {
  serialize: function() {
    var output = [];
    for(key in this) {
      output.push(key + ": " + this[key]);
    }
    return output.join(", ");
  }
  ...
};

为了能方便地将Mixin类中的方法添加到其他类中，我们可以扩展工具函数augment：

function augment(receivingClass, givingClass) {
  if (arguments[2]) { // 可接受三个参数，第三个参数为需添加的方法，多个方法可用数组将方法名传入
    if (arguments[2] instanceOf Array) {
      for (var i = 0, len = arguments[2].length; i < len; i++) {
        if (!receivingClass.prototype[arguments[2][i]]) {
          receivingClass.prototype[arguments[2][i]] = givingClass.prototype[arguments[2][i]];
        }
      }
    } else if (typeof arguments[2] === "string") {
      if (!receivingClass.prototype[arguments[2]]) {
        receivingClass.prototype[arguments[2]] = givingClass.prototype[arguments[2]];
      }
    }
  } else {
    for (methodName in givingClass.prototype) {
      if (!receivingClass.prototype[methodName]) {
        receivingClass.prototype[methodName] = givingClass.prototype[methodName];
      }
    }
  }
}

这时我们如果要给其他类添加Mixin中的方法的话可以直接这样写：

augment(MyBlog, Mixin);

类式继承存在的意义很大一部分是为了满足对Javascript的特性还不熟悉的程序员，毕竟这种方法是强行为了模仿其他面向对象语言的特性而创造的。Javascript的原型式特征在父类和子类之间建立了一种双向的联系，这是JS区别于其他语言的特点。
原型式继承发挥了JS的特性，所有的子类继承的方法会通过原型链逐级向父类查找，因此用于继承的方法在内存中只会保存一份，这样可以节约内存。只有在对子类的某个方法进行直接设置，将继承而来的方法覆盖的时候才会对新方法多带带生成副本。

一个经过封装的类，它的公用方法和特权方法可以被继承下来，因为它们是添加在原型链上的，在作为构造函数的时候可以继承给子类。而私用方法相当于作为了闭包中的变量，与原型链无关，因此不会被继承。

父类中的特权方法可以访问父类中的私用属性，而特权方法会被子类继承，因此子类也可以通过继承的特权方法间接访问父类的私用属性。但子类中新添加的特权方法不能访问父类中的私用属性，因为缺少了到达父类内部的原型链“通道”。