深入浅出原型链继承

众所周知，原型链中子级是可以继承父级的，常见的用法是构造函数，在new出新的实例后，实例会继承其原型上的所有属性和方法。这个一个特性，实际开发中也常常用到。
常见用法，

   Teacher.prototype.name='Mr.zhang'
    function Teacher(){};
    function Student(){};
    Student.prototype=Teacher.prototype//学生继承老师
    var s=new Student();
    var t=new Teacher();
    console.log(s);
    console.log(t);

如果学生方法继承老师方法原型，那么结果是：

如上图就是结果
如果此时，学生想在自己的原型上加一个属性age,我们来看看结果：

    Teacher.prototype.name='Mr.zhang'
    function Teacher(){};
    function Student(){};
    Student.prototype=Teacher.prototype//学生继承老师
    var s=new Student();
    var t=new Teacher();
    Student.prototype.age=18//学生给自己原型上加age属性
    console.log(s);
    console.log(t);

结果为：

在实际开发过程中，自己需求继承父级，但是自己又需要加新的属性，不想影响父级，不希望父级跟着加属性，因为父级还会被别的子级继承，这时就需要一给中间的过渡缓冲方法，这里我们封装继承方法：

    Teacher.prototype.name='Mr.zhang'
    function Teacher(){};
    function Student(){};
    
    // 调用继承方法
    inherit(Student,Teacher);
    var s=new Student();
    var t=new Teacher();
    Student.prototype.age=18//学生给自己原型上加age属性
    console.log(s);
    console.log(t);

    // 封装原型链中的圣杯继承模式
    function inherit(Target,Origin){
	  // 中间过渡方法   
      function Buffer(){}
      Buffer.prototype=Origin.prototype//Buffer的原型=开始方法的原型
      Target.prototype=new Buffer()//中间过渡方法的实例=目标方法的原型
      Target.prototype.constructor=Target //目标原型的构造器=它本身
      Target.prototype.super_class=Origin //目标原型的继承类=开始方法
    }

结果如下：

**上面的方法还可以继续优化，在团队多人开发中，常常需要给封装方法一个调用的出口，通过调用来让其执行，这样更符合开发规范，**如图：

 // 用调用的闭包方式封装继承方法
    var inherit=(function () {
      var Buffer=function(){}
      return function(Target,Origin){
        Buffer.prototype=Origin.prototype;
        Target.prototype=new Buffer();
        Target.prototype.constructor=Target;
        Target.prototype.super_class=Origin;
      }
    })();
    
    Teacher.prototype.name='Ms.cheng'
    function Teacher(){};
    function Student(){};
    function Buffer(){};
    
    inherit(Student,Teacher);
    Student.prototype.age=18//学生给自己原型上加age属性
    var t=new Teacher();
    var s=new Student();
   
    console.log(t);
    console.log(s);

举一个实际开发中的例子来实战一下：

   // 用调用的闭包方式封装继承方法
    var inherit=(function () {
      var Buffer=function(){}
      return function(Target,Origin){
        Buffer.prototype=Origin.prototype;
        Target.prototype=new Buffer();
        Target.prototype.constructor=Target;
        Target.prototype.super_class=Origin;
      }
    })();
    // 举一个实际开发中的例子来实战
var initpProgrammer =(function(){
  var Programmer=function(){};
  Programmer.prototype={
    name:'程序员',
    tool:'计算机',
    work:'编写程序',
    duration:'10个小时',
    say:function(){
     console.log(`我是一名${this.myName}${this.name}，我的工作是用${this.tool}${this.work}。
     我每天工作${this.duration}，我的工作需要用到${this.lang.toString()}。`);
    }
  }

  function FrontEnd(){};
  function BackEnd(){};

  inherit(FrontEnd,Programmer);
  inherit(BackEnd,Programmer);
  FrontEnd.prototype.lang=['HTML','CSS','Javascript'];
  FrontEnd.prototype.myName='前端';
  BackEnd.prototype.lang=['Node','Java','SQl'];
  BackEnd.prototype.myName='后端';

  return{
    FrontEnd:FrontEnd,
    BackEnd:BackEnd
  }

})();

var FrontEnd=new initpProgrammer.FrontEnd();
var BackEnd=new initpProgrammer.BackEnd();

FrontEnd.say();
BackEnd.say();

输出结果如下：