JavaScript组合继承怎么实现且避免父类构造函数执行两次

作者:函数茶馆

时间:2026-11-19

浏览:403

详细解析JavaScript传统组合继承中父类构造函数被执行两次的原因与副作用,并提供寄生组合式继承的标准实现方案与完整代码示例,彻底解决原型属性冗余与重复调用问题。

文章目录
分类:JavaScript核心原理 阅读时长:约8分钟
JavaScript组合继承怎么实现且避免父类构造函数执行两次
图 0:组合继承与寄生组合式继承机制核心对比缩略图

在 JavaScript 中,传统组合继承通过“在子类构造函数中借用父类构造函数”以及“将子类原型赋值为父类实例”来实现。这种方式虽然兼顾了实例属性的独立性和原型方法的共享,但会导致父类构造函数被执行两次,进而在子类原型上生成不必要的重复属性。要彻底避免二次执行,标准解法是采用寄生组合式继承:子类构造函数保留 Parent.call(this),而原型链连接改用 Object.create(Parent.prototype) 仅复制原型副本,不再实例化父类,并及时修复 constructor 指向。

一、传统组合继承的实现与“两次执行”问题剖析

组合继承(Combination Inheritance)是 JavaScript 原型开发中非常经典的一种继承模式,它结合了“构造函数借用”和“原型链连接”两种技术。

为了看清楚父类构造函数是在何时被触发的,我们可以看下面这段典型的组合继承代码:

// 1. 定义父类
function Parent(name) {
  this.name = name;
  this.colors = ['red', 'blue', 'green'];
  console.log('Parent 构造函数已执行'); // 跟踪调用位置
}

Parent.prototype.sayName = function() {
  console.log('我的名字是:' + this.name);
};

// 2. 定义子类并在内部借用父类构造函数
function Child(name, age) {
  Parent.call(this, name); // 【第 2 次执行】:在实例化每个 Child 时调用
  this.age = age;
}

// 3. 原型链继承
Child.prototype = new Parent(); // 【第 1 次执行】:为了建立原型链而实例化 Parent
Child.prototype.constructor = Child; // 修复 constructor 属性

在上述代码中,父类构造函数 Parent 总共被调用了两次:

  1. 第一次调用发生在绑定原型时:Child.prototype = new Parent()。此时代码只是为了让 Child.prototype 能够访问到 Parent.prototype 上的方法,但因为使用了 new Parent(),被迫执行了一遍 Parent 的全部逻辑。这导致 Child.prototype 上多出了 name 和 colors 这两个本该属于具体实例的属性。
  2. 第二次调用发生在实例化子类时:每当调用 const child1 = new Child('Tom', 12) 时,Child 内部的 Parent.call(this, name) 会再次执行父类构造函数,并在 child1 实例自身挂载一份崭新的 name 和 colors。
JavaScript组合继承怎么实现且避免父类构造函数执行两次
图 1:传统组合继承两次执行导致原型上存在同名冗余属性的遮蔽图

为什么执行两次会有负面影响?

两次调用的主要缺陷体现在两方面:

  • 性能损耗与潜在副作用:如果 Parent 构造函数中包含复杂的计算、网络注册、DOM 监听等初始化逻辑,调用两次意味着这些消耗与副作用会被无谓触发两遍。
  • 同名属性冗余与遮蔽:如上图所示,Child.prototype 上存在一份初始属性(如 name: undefined),而 child1 实例自身也有一份。虽然实例属性通过原型链查找机制遮蔽(Shadow)了原型属性,使得程序在表面上运行正常,但这部分原型属性不仅浪费内存空间,若后续通过 delete child1.name 删除实例属性时,还会暴露出原型上的旧值,造成逻辑隐患。

二、核心解法:基于寄生组合式继承避免二次调用

要想彻底解决上述问题,我们首先要明确需求:子类原型究竟需要什么?

子类原型只需要能够沿着原型链访问到 Parent.prototype 上的方法即可,完全不需要执行 Parent 构造函数来获取其实例属性。因为实例属性在子类实例化时,已经由 Parent.call(this) 精准且独立地赋给每个子类实例了。

因此,解决思路非常明确:不使用 new Parent(),而是创建一个继承自 Parent.prototype 的“空对象”作为子类原型。

JavaScript组合继承怎么实现且避免父类构造函数执行两次
图 2:三种原型链连接机制对比(只有方式三兼具无冗余执行与原型隔离)

认识 Object.create 的底层原理

ES5 引入的 Object.create(proto) 可以创建一个新对象,并将该新对象的内部原型 [[Prototype]](即 __proto__)指向传入的 proto 对象。

如果运行环境不支持 Object.create,其 polyfill(垫片)原理实质上非常朴素:借助一个空的临时构造函数作为桥梁:

function createObject(proto) {
  function F() {}       // 1. 创建一个完全没有属性的空构造函数
  F.prototype = proto;  // 2. 将空构造函数的原型指向目标父类原型
  return new F();       // 3. 实例化空构造函数,返回一个纯净的对象
}

由于 F 是空函数,new F() 执行时不会做任何多余的初始化操作,返回的对象只具备一条指向 Parent.prototype 的原型链,从而完美规避了执行 Parent 构造函数产生的副作用。

三、寄生组合式继承的标准实现步骤与完整代码

实现寄生组合式继承的核心步骤可以分为四步:

  1. 在子类中借用父类构造函数:子类内部通过 Parent.call(this, ...args) 传递参数并绑定专属的实例属性。
  2. 创建父类原型的副本:使用 Object.create(Parent.prototype) 创建一个空对象,其原型指向 Parent.prototype。
  3. 修正 constructor 指针:因为重写了子类原型,新对象的 constructor 默认会指向 Parent,需要显式指定 prototype.constructor = Child。
  4. 赋值并扩展子类方法:将创建好的原型对象赋给 Child.prototype,随后在其上声明子类独有的方法。
JavaScript组合继承怎么实现且避免父类构造函数执行两次
图 3:寄生组合式继承标准操作步骤与关键职责分解流程图

完整可运行代码实现

在实际工程中,通常会将步骤 2 与步骤 3 封装为一个通用工具函数 inheritPrototype。完整代码如下:

// 通用原型继承工具函数
function inheritPrototype(child, parent) {
  // 1. 创建父类原型的一个副本(纯净对象,未执行 Parent 构造函数)
  const prototype = Object.create(parent.prototype);
  
  // 2. 修复 constructor 指针,使其指向正确的子类构造函数
  prototype.constructor = child;
  
  // 3. 将该原型对象赋值给子类的原型
  child.prototype = prototype;
}

// ---------------- 实际业务代码 ----------------

// 1. 定义父类
function Parent(name) {
  this.name = name;
  this.colors = ['red', 'blue', 'green'];
  console.log('Parent 构造函数被执行!参数 name:', name);
}

Parent.prototype.sayName = function() {
  console.log('我的名字:' + this.name);
};

// 2. 定义子类
function Child(name, age) {
  // 借用构造函数:这是父类构造函数【唯一一次】执行的时机
  Parent.call(this, name);
  this.age = age;
}

// 3. 建立寄生组合式原型继承关系
inheritPrototype(Child, Parent);

// 4. 在子类原型上扩展专属方法(必须在 inheritPrototype 之后进行)
Child.prototype.sayAge = function() {
  console.log('我的年龄:' + this.age);
};

// ---------------- 验证测试 ----------------
console.log('--- 开始创建子类实例 ---');
const child1 = new Child('Alice', 20);
const child2 = new Child('Bob', 25);

// 验证 1:方法与属性继承
child1.sayName(); // 输出: "我的名字:Alice"
child1.sayAge();  // 输出: "我的年龄:20"

// 验证 2:引用类型属性独立性
child1.colors.push('black');
console.log('child1 colors:', child1.colors); // ['red', 'blue', 'green', 'black']
console.log('child2 colors:', child2.colors); // ['red', 'blue', 'green'] (未被污染)

// 验证 3:原型链与 constructor 判定
console.log(child1 instanceof Child);         // true
console.log(child1 instanceof Parent);        // true
console.log(child1.constructor === Child);    // true
console.log(Child.prototype.hasOwnProperty('name')); // false (原型上无冗余属性!)
代码关键点提醒: 子类原型方法的声明(例如 Child.prototype.sayAge = ...)必须写在 inheritPrototype(Child, Parent) 之后。如果在之前声明,赋值新原型对象时会将之前挂载在原有原型上的方法彻底覆盖。

四、两种继承模式在同一条件下的全维度对比

为了直观评估寄生组合式继承带来的改进,我们将传统组合继承与寄生组合式继承放在完全一致的运行条件下进行横向对比:

对比维度 传统组合继承 (Combination) 寄生组合式继承 (Parasitic Combination) 差异带来的影响
父类构造函数执行次数 2 次(new Parent() + Parent.call(this)) 1 次(仅在 new Child() 时调用一次) 消除重复运算开销,杜绝重复触发初始化副作用
子类原型属性状态 包含多余且未赋值的父类实例属性(如 name: undefined) 空对象,只含有 constructor 及 __proto__ 指针 原型更纯净,节省内存空间,不存在属性遮蔽隐患
原型引用隔离性 相互隔离(子类方法不影响父类原型) 相互隔离(通过副本连接,不影响父类原型) 两者均能保证子类对原型的改动不影响父类
类型判定支持 正常支持(instanceof 和 isPrototypeOf 有效) 正常支持(instanceof 和 isPrototypeOf 有效) 符合标准的原型链查找规则
实现复杂度 简单直接,无需额外辅助工具函数 需要额外的原型副本创建步骤 只需封装一个 3 行的工具函数,收益远大于成本
JavaScript组合继承怎么实现且避免父类构造函数执行两次
图 4:两种继承模式收益总结与上线实施自查清单

五、注意事项与常见踩坑点

1. 为什么不能直接写 Child.prototype = Parent.prototype?

部分初学者为了省事,可能会直接将父类原型赋值给子类原型。这种做法虽然也不执行父类构造函数,但其后果极其严重:

致命错误: JavaScript 中对象是引用传递的。一旦执行 Child.prototype = Parent.prototype,子类原型与父类原型将指向同一块内存地址。此时,修复子类构造函数指向 Child.prototype.constructor = Child,会同时把 Parent.prototype.constructor 也改成 Child!此外,任何给子类原型扩展的方法,父类实例也能直接调用,完全破坏了面向对象的继承隔离性。

2. 修复 constructor 的必要性

重写整个 Child.prototype 后,新对象的原型链会向上查找到 Parent.prototype.constructor(即指向 Parent)。如果不显式修正:

prototype.constructor = child;

在后续逻辑中,依赖 instance.constructor 判断对象类型、或通过 new child.constructor() 动态反射创建同类实例的代码就会全部失真,甚至误创建出父类实例。

3. 与 ES6 class extends 的关联

很多现代开发者习惯直接使用 ES6 的 class Child extends Parent 语法。事实上,Babel 等主流编译器在将 ES6 extends 转译为 ES5 代码时,底层所采用的核心机制正是寄生组合式继承:

  • super(...args) 在底层对应的是借用父类构造函数 Parent.call(this, ...args)。
  • 原型链的建立同样通过类似 Object.create(Parent.prototype) 的桥接方式完成。

因此,掌握寄生组合式继承不仅能帮助你在不使用 class 的场景下写出高性能的继承代码,也能让你深刻理解现代 JavaScript 类语法糖背后的真实运行机制。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章