11.原型链的一个重要应用：圣杯模式

一些应该掌握的知识点

• JS中并没有真正意义上的继承，所谓的继承只是利用了原型和原型链的方法，同时在使用这些方法时会产生一些额外的且不希望产生的影响——创建作用域

• 普通继承方式的缺陷：

  • 传统的继承方式(如博文10.原型中的原型链案例所示)过多地继承了没有用的属性
  • 借用构造函数来继承会导致：
    
    1. 不能继承借用构造函数的原型
    2. 每次构造函数都要多走一个函数
  • 用共享原型来继承，不能随便改动自己的原型

• 一种更有优势的继承方式：圣杯模式
  案例分析：一个败家儿子案例

//当前案例是一个共享原型案例
Father.prototype.lastname = 'C'; //父亲的姓为C
Father.prototype.fortune = 1000000; //父亲拥有财产一百万
function Father () { //创建父亲函数
    this.age = 48; //父亲48岁
}
var father = new Father(); //用构造函数创建对象父亲
Son.prototype = Father.prototype; /* 败家儿子只图你的财，不图你的年纪，
                                     你的钱就是我的钱(共享你的原型) */
Son.prototype.lastname = 'x'; //败家儿子试图通过改姓来认贼作父
function Son () { //创建儿子函数
  this.age = 18; //儿子18岁
  this.waste = function () { //败家儿子爱挥霍
     return this.fortune - 50000; /* 败家儿子每挥霍一次，
                                     家产就减少五万 */
  }
}
var son = new Son(); //用构造函数创建对象败家儿子
console.log(son.age, son.lastname, son.waste()); /* 控制台显示败家
                                                    儿子第一次挥霍
                                                    后所剩的家产 */
console.log(son.lastname); //控制台显示x，败家儿子成功认贼作父
console.log(father.lastname); //控制台显示x，父亲的姓也被改了，这是不行的

　　由上例可看出，在共享原型中，对象试图改变自己的原型的一些属性时将会影响到其他对象，这是不希望被看到的情况。
　　若对象希望改变自己的原型的一些属性同时也不影响其他属性，可以使用圣杯模式，案例如下所示。

//当前案例是一个圣杯模式案例
Father.prototype.lastname = 'C';
Father.prototype.fortune = 1000000;
function Father () {
    this.age = 48;
}
function Son () {
    this.age = 18;
    this.waste = function () {
        return this.fortune - 50000;
    }
}
var inherit = (function () { //创建圣杯inherit函数
/* 使用立即函数的原因：函数执行前会进行预编译，预编译过程都会产生AO，
如当前案例所示，案例中的立即执行函数(注：以下简称立函)执行前预编译的AO中有buffer函数，
由于当立函执行完毕时会返回一个匿名函数(注：以下简称匿函)，这个匿函调用了buffer函数，
最终匿函也被赋予到了inherit函数中，导致立函执行前预编译产生的AO在立函执行完毕后并不会销毁，
于是buffer函数成为了一个闭包并被一同赋予到了inherit函数中去了，
这样当在外部使用inherit函数时，将会一直都在使用一个buffer函数，
而不用每次使用时都再新建一个buffer函数 */
return function (targetSon, originFather) { //让目标儿子继承源头父亲
    function buffer () {} //buffer函数是一个闭包，仅用做一个缓冲而不做他用
    buffer.prototype = originFather.prototype; 
    //targetSon.prototype = buffer.prototype; /* 不能这么写，因为这样写就相当于对象targetSon、fatherOrigin和buffer共享原型了 */
    targetSon.prototype = new buffer(); /* 使对象targetSon试图修改自身属性时仅仅是以buffer函数作为对象进行修改，而不会影响到其他对象 */
    targetSon.prototype.constructor = targetSon; //令目标儿子记得自己本质是谁
    targetSon.prototype.gene = originFather; //令目标儿子记得自己的生父是谁
    }
    })()
inherit(Son, Father); //调用圣杯inherit函数
Son.prototype.lastname = 'X';
var son = new Son();
var father = new Father();
console.log(son.lastname); //控制台显示x，败家儿子成功认贼作父
console.log(father.lastname); /* 控制台显示c，父亲自己的姓并没有因为败家儿子
                                 通过改姓来认贼作父的惨痛事实而改变 */
console.log(son.constructor); //控制台显示儿子自己的构造函数(本质)
console.log(son.gene); //控制台显示儿子自己的生父

　　如上例所示可瞧见，通过圣杯模式可以把一个家族中的各个对象的干扰给截断，以使每个对象在对父类有继承的情况下相互独立，以免各个对象在试图修改自身(特别是自身原型)的属性时影响到其他对象。