JavaScript 中继承实现方式归纳

太过爱你忘了你带给我的痛 2022-08-07 14:59 151阅读 0赞

不同于基于类的编程语言，如C++ 和Java，JavaScript 中的继承方式是基于原型的。同时由于JavaScript 是一门非常灵活的语言，其实现继承的方式也非常多。  
首要的基本概念是关于构造函数和原型链的，父对象的构造函数称为Parent，子对象的构造函数称为Child，对应的父对象和子对象分别为parent和child。  
  
对象中有一个隐藏属性\[\[prototype\]\](注意不是prototype)，在 Chrome 中是\_\_proto\_\_，而在某些环境下则不可访问，它指向的是这个对象的原型。在访问任何一个对象的属性或方法时，首先会搜索本对象的所有属性，如果找不到的话则会根据\[\[prototype\]\]沿着原型链逐步搜索其原型对象上的属性，直到找到为止，否则返回undefined。  
  
原型链继承：  
  
原型链是 JavaScript 中实现继承的默认方式，如果要让子对象继承父对象的话，最简单的方式是将子对象构造函数的prototype属性指向父对象的一个[实例][Link 1]：

1.  function Parent() \{\}  
    
2.  function Child() \{\}  
    
3.  Child.prototype = new Parent()

复制代码

这个时候，Child的prototype属性被重写了，指向了一个新对象，但是这个新对象的constructor属性却没有正确指向Child，JS 引擎并不会自动为我们完成这件工作，这需要我们手动去将Child的原型对象的constructor属性重新指向Child:

1.  Child.prototype.constructor = Child

复制代码

以上就是 JavaScript 中的默认继承机制，将需要重用的属性和方法迁移至原型对象中，而将不可重用的部分设置为对象的自身属性，但这种继承方式需要新建一个实例作为原型对象，效率上会低一些。

原型继承（非原型链）：  
为了避免上一个方法需要重复创建原型对象实例的问题，可以直接将子对象构造函数的prototype指向父对象构造函数的prototype，这样，所有Parent.prototype中的属性和方法也能被重用，同时不需要重复创建原型对象实例：

1.  Child.prototype = Parent.prototype  
    
2.  Child.prototype.constructor = Child

复制代码

但是我们知道，在 JavaScript 中，对象是作为引用类型存在的，这种方法实际上是将Child.prototype和Parent.prototype中保存的指针指向了同一个对象，因此，当我们想要在子对象原型中扩展一些属性以便之后继续继承的话，父对象的原型也会被改写，因为这里的原型对象实例始终只有一个，这也是这种继承方式的缺点。

临时构造器继承：  
  
为了解决上面的问题，可以借用一个临时构造器起到一个中间层的作用，所有子对象原型的操作都是在临时构造器的实例上完成，不会影响到父对象原型：

1.  var F = function() \{\}  
    
2.  F.prototype = Parent.prototype  
    
3.  Child.prototype = new F()  
    
4.  Child.prototype.constructor = Child

复制代码

同时，为了可以在子对象中访问父类原型中的属性，可以在子对象构造器上加入一个指向父对象原型的属性，如uber，这样，可以在子对象上直接通过child.constructor.uber访问到父级原型对象。  
  
我们可以将上面的这些工作封装成一个函数，以后调用这个函数就可以方便实现这种继承方式了：

1.  function extend(Child, Parent) \{  
    
2.      var F = function() \{\}  
    
3.      F.prototype = Parent.prototype  
    
4.      Child.prototype = new F()  
    
5.      Child.prototype.constructor = Child  
    
6.      Child.uber = Parent.prototype  
    
7.  \}

复制代码

然后就可以这样调用：

1.  extend(Dog, Animal)

复制代码

属性拷贝：  
这种继承方式基本没有改变原型链的关系，而是直接将父级原型对象中的属性全部复制到子对象原型中，当然，这里的复制仅仅适用于基本数据类型，对象类型只支持引用传递。

1.  function extend2(Child, Parent) \{  
    
2.      var p = Parent.prototype  
    
3.      var c = Child.prototype  
    
4.      for (var i in p) \{  
    
5.          c\[i\] = p\[i\]  
    
6.      \}  
    
7.      c.uber = p  
    
8.  \}

复制代码

这种方式对部分原型属性进行了重建，构建对象的时候效率会低一些，但是能够减少原型链的查找。不过我个人觉得这种方式的优点并不明显。  
  
对象间继承：  
除了基于构造器间的继承方法，还可以抛开构造器直接进行对象间的继承。即直接进行对象属性的拷贝，其中包括浅拷贝和深拷贝。

浅拷贝：

接受要继承的对象，同时创建一个新的空对象，将要继承对象的属性拷贝至新对象中并返回这个新对象：

1.  function extendCopy(p) \{  
    
2.      var c = \{\}  
    
3.      for (var i in p) \{  
    
4.          c\[i\] = p\[i\]  
    
5.      \}  
    
6.      c.uber = p  
    
7.      return c  
    
8.  \}

复制代码

拷贝完成之后对于新对象中需要改写的属性可以进行手动改写。

深拷贝：  
浅拷贝的问题也显而易见，它不能拷贝对象类型的属性而只能传递引用，要解决这个问题就要使用深拷贝。深拷贝的重点在于拷贝的递归调用，检测到对象类型的属性时就创建对应的对象或数组，并逐一复制其中的基本类型值。

1.  function deepCopy(p, c) \{  
    
2.      c = c || \{\}  
    
3.      for (var i in p) \{  
    
4.          if (p.hasOwnProperty(i)) \{  
    
5.              if (typeof p\[i\] === 'object') \{  
    
6.                  c\[i\] = Array.isArray(p\[i\]) ? \[\] : \{\}  
    
7.                  deepCopy(p\[i\], c\[i\])  
    
8.              \} else \{  
    
9.                  c\[i\] = p\[i\]  
    
10.             \}  
    
11.         \}  
    
12.     \}  
    
13.     return c  
    
14. \}

复制代码

其中用到了一个 ES5 的Array.isArray()方法用于判断参数是否为数组，没有实现此方法的环境需要自己手动封装一个 shim。

1.  Array.isArray = function(p) \{  
    
2.      return p instanceof Array  
    
3.  \}

复制代码

但是使用instanceof操作符无法判断来自不同框架的数组变量，但这种情况比较少。  
  
  
原型继承：  
  
  
借助父级对象，通过构造函数创建一个以父级对象为原型的新对象：

1.  function object(o) \{  
    
2.      var n  
    
3.      function F() \{\}  
    
4.      F.prototype = o  
    
5.      n = new F()  
    
6.      n.uber = o  
    
7.      return n  
    
8.  \}

复制代码

这里，直接将父对象设置为子对象的原型，ES5 中的Object.create()方法就是这种实现方式。  
  
  
原型继承和属性拷贝混用：  
  
  
原型继承方法中以传入的父对象为原型构建子对象，同时还可以在父对象提供的属性之外额外传入需要拷贝属性的对象：

1.  function ojbectPlus(o, stuff) \{  
    
2.      var n  
    
3.      function F() \{\}  
    
4.      F.prototype = o  
    
5.      n = new F()  
    
6.      n.uber = o  
    
7.    
    
8.      for (var i in stuff) \{  
    
9.          n\[i\] = stuff\[i\]  
    
10.     \}  
    
11.     return n  
    
12. \}

复制代码

多重继承：  
  
  
这种方式不涉及原型链的操作，传入多个需要拷贝属性的对象，依次进行属性的全拷贝：

1.  function multi() \{  
    
2.      var n = \{\}, stuff, i = 0,  
    
3.          len = arguments.length  
    
4.      for (i = 0; i < len; i++) \{  
    
5.          stuff = arguments\[i\]  
    
6.          for (var key in stuff) \{  
    
7.              n\[i\] = stuff\[i\]  
    
8.          \}  
    
9.      \}  
    
10.     return n  
    
11. \}

复制代码

根据对象传入的顺序依次进行拷贝，也就是说，如果后传入的对象包含和前面对象相同的属性，后者将会覆盖前者。  
  
  
构造器借用：  
  
  
JavaScript中的call()和apply()方法非常好用，其改变方法执行上下文的功能在继承的实现中也能发挥作用。所谓构造器借用是指在子对象构造器中借用父对象的构造函数对this进行操作：

1.  function Parent() \{\}  
    
2.  Parent.prototype.name = 'parent'  
    
3.    
    
4.  function Child() \{  
    
5.      Parent.apply(this, arguments)  
    
6.  \}  
    
7.  var child = new Child()  
    
8.  console.log(child.name)

复制代码

这种方式的最大优势就是，在子对象的构造器中，是对子对象的自身属性进行完全的重建，引用类型的变量也会生成一个新值而不是一个引用，所以对子对象的任何操作都不会影响父对象。  
  
  
而这种方法的缺点在于，在子对象的构建过程中没有使用过new操作符，因此子对象不会继承父级原型对象上的任何属性，在上面的代码中，child的name属性将会是undefined。  
  
  
要解决这个问题，可以再次手动将子对象构造器原型设为父对象的实例：

1.  Child.prototype = new Parent()

复制代码

但这样又会带来另一个问题，即父对象的构造器会被调用两次，一次是在父对象构造器借用过程中，另一次是在继承原型过程中。  
  
  
要解决这个问题，就要去掉一次父对象构造器的调用，构造器借用不能省略，那么只能去掉后一次调用，实现继承原型的另一方法就是迭代复制：

1.  extend2(Child, Parent)

复制代码

使用之前实现的extend2()方法即可。

[Link 1]: http://www.html5cn.org/portal.php?mod=list&catid=17