一、继续的观点

继续，是面向对象言语的一个主要观点。
一般有这两种继续体式格局：接口继续和完成继续。接口继续只继续要领署名，而完成继续则继续现实的要领。

《JS高程》里提到：“由于函数没有
署名，在‘ECMAScript’中没法完成
接口继续。”

等等，函数署名是什么东西？据MDN文档定义以下：

函数署名（范例署名、要领署名）定义了函数或要领的输入与输出。

署名可包括以下内容：

• 参数 及参数的 范例
• 一个的返回值及其范例
• 可能会抛出或传回的非常
• 该要领在 面向对象顺序中的可用性方面的信息（如public、static或prototype）。

看起来好庞杂啊，我们换成强范例的言语的角度会不会更好明白？
比如，C的函数署名就是我们熟习的函数声明：

int func(double d);

此时：参数名为d，参数范例为double，返回值为func(d)，返回值范例为int。
再如，Java的函数署名：

public static void main(String[] args)

此时：参数名为args，参数范例为String []，返回值范例为void所以该要领没有返回值，接见修饰符public示意该要领是公有要领，static示意该要领是一个类要领而非实例要领……

如今，我们晓得函数署名是怎样回事了。那末，接口继续又是什么东西？置信人人会遥想起Java中的interface，implements等……在此就不班门弄斧了。

我们晓得，JavaScript是范例松懈的言语，不像Java它们有严厉的变量范例搜检。所以，JS的函数才没有署名，才没法完成接口继续。

那末，JS的完成继续是怎样回事呢？

二、JS的继续

1. 原型链的基本情势
   明白：经由历程建立SuperType的实例，并将该实例赋给SubType.prototype，来完成SubType继续SuperType。instance的原型指向SubType，SubType的原型指向SuperType，SuperType的原型指向Object，云云构成了原型链。
   瑕玷：对象实例同享一切继续的属性和要领，不适宜零丁实用

   function SuperType() {
       this.property = true;
   }
   SuperType.prototype.getSuperValue = function() {
       return this.property;
   };
   function SubType() {
     this.subproperty = false;
   }
   //SubType继续SuperType
   SubType.prototype = new SuperType();
   SubType.prototype.getSubValue = function() {
     return this.subproperty;
   };
   var instance = new SubType();
   alert(instance.getSuperValue());  //true

   因而，有下一个招式，来处理包括援用范例值的原型属性会被一切实例同享的缺点。

2. 借用组织函数
   明白：“借用”超范例组织要领，在新的子范例对象上实行超范例函数定义的一切对象初始化代码
   实用：处理超范例的援用范例值被一切子范例对象实例同享，而且子范例可向超范例传参
   瑕玷：不能做到函数复用，从而下降效力，不适宜零丁实用

   function SuperType(name) {
     this.name = name;
     this.colors = ["red", "blue", "green"]; //援用范例值
   }
   function SubType() {
     SuperType.call(this, "A"); //继续SuperType “借用”超范例的组织函数 并传参
     this.age = 20;    //实例属性
   }
   var instance1 = new SubType();    //instance1.name: "A", instance1.age: 20
   instance1.colors.push("black"); //instance1.colors: "red, blue, green, black"
   var instance2 = new SubType();  //instance2.colors: "red, blue, green"

   接下来，组合妙技出大招！

3. 组合继续
   明白：将原型链和借用组织函数组合到一同，经由历程原型链来继续同享的原型属性和要领，经由历程借用组织函数来继续实例属性。
   实用：最经常使用的继续情势。
   瑕玷：挪用两次超范例组织函数，在SubType上建立了过剩的属性，形成超范例对象的实例属性的重写

   function SuperType(name) {
     this.name = name;
     this.colors = ["red", "blue", "green"];
   }
   SuperType.prototype.sayName = function() {
     alert(this.name);
   };
   function SubType(name, age) {
     SuperType.call(this, name);   //继续属性 第二次挪用超范例组织函数 新实例获得两个实例属性name,colors
     this.age = age;
   }
   SubType.prototype = new SuperType();  //继续要领 第一次挪用超范例组织函数 SubType.prototype获得两个实例属性name,colors
   SubType.prototype.sayAge = function() {
     alert(this.age);
   };
   
   var instance1 = new SubType("mm", 18);
   instance1.colors.push("black");
   alert(instance1.colors);  //"red, blue, green, black"
   instance1.sayName();  //"mm"
   instance1.sayAge();  //18
   
   var instance2 = new SubType("弟弟", 20);
   alert(instance2.colors);  //"red, blue, green"
   instance2.sayName();  //"弟弟"
   instance2.sayAge();  //20

   这是打boss的大招，那我怎样应付小怪？

4. 原型式继续
   明白：实质是对给定对象的浅复制
   实用：没必要预先定义组织函数来完成继续，只想让一个对象与另一个对象坚持相似
   瑕玷：援用范例值的属性被同享，犹如原型情势一样

   function object(o) {    //对o举行浅复制
     function F() {}    //建立一个临时性的组织函数
     F.prototype = o;    //将传入的对象o作为F的原型
     return new F();    //返回F的新实例
   }
   
   var person = {
     name: "A",
     friends: ["B", "C", "D"]
   };
   var anotherPerson = object(person);    // Object.create(person)
   anotherPerson.name = "E";
   anotherPerson.friends.push("F");
   var yetAnotherPerson = object(person);    //Object.create(person)
   yetAnotherPerson.name = "G";
   yetAnotherPerson.friends.push("H");
   alert(person.friends);  //"B, C, D, F, H" 援用范例值的属性被同享啦

   注重：Object.create()要领的第二个参数，新对象的分外属性的对象，会掩盖原型对象上的同名属性。

   var anotherPerson = Object.create(person, {
     name: { value: "E" }
   });
   alert(anotherPerson.name);   // "E"

   打了这么久，能不能让小招也晋级（封装）一下啊？

5. 寄生式继续

   建立一个仅用于封装继续历程的函数，该函数在内部以某种体式格局来加强对象，末了再像真的是它做了一切事情一样返回对象。

   明白：继续的事情是经由历程挪用函数完成的，所以是“寄生”，将继续事情依靠给他人做，本身只是做加强事情。
   实用：基于某个对象或某些信息来建立对象，而不斟酌自定义范例和组织函数。
   瑕玷：不能做到函数复用，从而下降效力

    function createAnother(original) {
      var clone = object(original); //经由历程挪用函数建立一个新对象
      clone.sayHi = function() {  //以某种体式格局来加强这个对象
        alert("hi");
      }
      return clone;
    }
    var person = {
      name: "A",
      friends: ["B", "C", "D"]
    };
    var anotherPerson = createAnother(person);  //不仅有person一切属性要领，另有本身的sayHi要领
    anotherPerson.sayHi();  //"hi"

   履历攒足，我要把之前打boos的组合大招升到满级！

6. 寄生组合继续
   明白：经由历程借用组织函数来继续属性，经由历程原型链的混用情势来继续要领。用寄生式继续来继续超范例的原型，再将加强后的效果指定给子范例的原型。
   实用：援用范例最理想的继续情势，高效，只挪用了一个SuperType组织函数

   function inheritPrototype(subType, superType) {
     var prototype = object(superType.prototype); //建立对象 超范例原型的副本
     prototype.constructor = subType;  //加强对象 填补因重写原型而落空默许的constructor属性
     subType.prototype = prototype;  //指定对象
   }
   
   function SuperType(name) {
     this.name = name;
     this.colors = ["red", "blue", "green"];
   }
   SuperType.prototype.sayName = function() {
     alert(this.name);
   };
   function SubType(name, age) {
     SuperType.call(this, name);   //继续属性
     this.age = age;
   }
   inheritPrototype(SubType, SuperType);  //继续要领
   SubType.prototype.sayAge = function() {
     alert(this.age);
   };

三、ES6的继续

extends关键字用来建立一个一般类或许内建对象的子类。

class A {
    ...
}
class B extends A {
    ...
}

个中，

B.__proto__ === A // true
B.prototype.__proto__ === A.prototype // true

由于extends完成了：

Object.setPrototypeOf(B.prototype, A.prototype);    //B.prototype.__proto__ = A.prototype;

Object.setPrototypeOf(B, A);    //B.__proto__ = A

extends更详细的完成要领拜见面试官问：JS的继续，在此就不班门弄斧了~

完~如有不足，请多指教，不胜感激！

以上代码借鉴于《JS高等顺序设计》