JavaScript中call和apply在继承中的作用是什么

作者:木棉时间:2026-11-18 23:10:14浏览:458

深入剖析JavaScript中call与apply在继承中的核心作用:通过借用父类构造函数实现实例属性的独立初始化与物理隔离,彻底避免引用类型属性共享污染,并结合原型链构建成熟完整的继承方案。

在 JavaScript 传统的面向对象编程中,call 和 apply 在继承中的核心作用是“借用父类构造函数”(Constructor Stealing):通过在子类构造函数内部显式调用父类构造函数,并将其内部的 this 绑定到当前正在创建的子类实例上,直接将父类中定义的实例属性和初始化代码复制到子类实例中。这一机制彻底解决了原型链继承中“引用类型属性被所有实例共享互串”和“无法向父类构造函数灵活传参”的两大痛点,是构建 JavaScript 独立实例属性继承的基石。
JavaScript中call和apply在继承中的作用是什么
图 1:借用构造函数的核心定位与实例属性隔离机制

一、核心作用:通过改变 this 指向实现“属性借用”

要弄清楚 call 和 apply 在继承中的作用,首先需要理解 JavaScript 的对象实例化机制。当外部使用 new Child() 创建实例时,JavaScript 引擎会在堆内存中开辟一块新的对象空间,并将子类构造函数体内部的 this 绑定到这个全新对象上。

如果在子类构造函数中像普通函数一样直接执行 Parent(),父类函数内部的 this 会遵循普通函数调用规则:在非严格模式下指向全局对象(window 或 global),在严格模式下则是 undefined。这样不仅无法为新实例初始化属性,还会意外污染全局环境或抛出异常。

而借由 Parent.call(this, ...) 或 Parent.apply(this, ...),子类构造函数将自身的 this(即刚出生的新实例)作为上下文强行传递给了父类构造函数。此时,父类构造函数内部所有 this.xxx = yyy 的赋值动作,都会直接就地写入到该子类实例身上。

为什么纯原型链继承无法胜任?
如果仅通过原型链继承(例如 Child.prototype = new Parent()),父类中定义的数组、对象等引用类型属性就会驻留在 Child.prototype 这个公共对象上。只要某一个子类实例修改了该数组(如 child1.colors.push('black')),所有其他实例的 colors 都会同步发生变动。借用构造函数的首要价值,就是让每个实例都拥有一份独立的引用属性副本。

二、关键执行推导:内存分配与上下文流转过程

我们可以通过一段典型的代码来观察这一机制的实际运行过程:

function Parent(name) {
  this.name = name;
  this.colors = ['red', 'blue'];
}

function Child(name, age) {
  // 核心:借用父类构造函数,并把当前新实例的 this 传过去
  Parent.call(this, name);
  this.age = age; // 子类自有属性
}

const child1 = new Child('小明', 12);
const child2 = new Child('小红', 14);

child1.colors.push('black');

console.log(child1.name);   // "小明"
console.log(child1.colors); // ["red", "blue", "black"]
console.log(child2.colors); // ["red", "blue"] (完全独立,未受污染)

从代码执行的生命周期来看,整个流转过程清晰地分为四个关键阶段:

  1. 分配子类实例上下文:执行 new Child('小明', 12) 时,JS 引擎创建空对象,设置其原型链指向 Child.prototype,并将子类内部的 this 绑定到该空对象。
  2. 借用父类重定向执行:子类内部执行 Parent.call(this, name),父类函数被调用,且父类执行上下文中的 this 被显式指定为上一步创建的子类空对象。
  3. 原地写入父类属性:父类执行 this.name = name 和 this.colors = ['red', 'blue'],直接将属性作为子类实例的自有属性(Own Properties)写入该内存块。
  4. 子类追加特有属性:子类构造函数继续往下执行自有逻辑(this.age = 12),最后将构造完毕的实例对象返回。
JavaScript中call和apply在继承中的作用是什么
图 2:new Child() 触发 call / apply 时的内存与上下文流转四步法

三、call 与 apply 在继承中的应用差异与技巧

call 和 apply 在功能核心上完全等价:都是 Function.prototype 上的原生方法,第一个参数都用于指定目标函数的 this 指向。它们在继承中的唯一区别,在于向父类构造函数传递后续参数的形式不同。

1. call:逐个传递,适合参数固定明确的场景

当子类清楚了解父类需要哪些参数,或者需要在传入父类前对参数进行类型转换、默认值赋予或解构时,使用 call 是最直观的做法:

function Animal(name, age) {
  this.name = name;
  this.age = age;
}

function Dog(name, age, breed) {
  // 参数逐一清晰罗列
  Animal.call(this, name, age);
  this.breed = breed;
}

2. apply:数组/集合批量转发,适合动态透传与通用封装

apply 第二个参数接收一个数组或类数组对象。在编写通用的基类代理、框架中间件、或者子类不需要关注父类参数细节只需原样转发时,apply 配合 arguments 能够极大地精简代码:

function BaseLogger(level, prefix, timestamp) {
  this.level = level;
  this.prefix = prefix;
  this.timestamp = timestamp;
}

function CustomLogger() {
  // 动态将子类接收到的全部实参无损透传给父类
  BaseLogger.apply(this, arguments);
  this.isCustom = true;
}

3. 现代延伸:ES6 扩展运算符让两者合二为一

在支持 ES6+ 的环境中,借助于剩余参数(Rest Parameters)与扩展运算符(Spread Syntax),可以直接书写 Parent.call(this, ...args)。这种写法既保留了 call 语义的直接性,又完全拥有了 apply 接收动态数组的便利,现代代码库中已基本以此为主。

JavaScript中call和apply在继承中的作用是什么
图 3:call 与 apply 在继承传参机制上的特点与对比

四、局限性剖析:为什么单独使用 call / apply 无法完成完整继承

虽然借用构造函数完美解决了实例属性隔离和传参问题,但绝不能把“借用构造函数”等同于“完成了继承”。如果只写 Parent.call(this),会暴露出两个严重的局限:

  • 无法继承父类原型链上的方法: call 和 apply 仅仅是把父类构造函数当作普通函数执行了一遍,并没有触碰任何原型链机制。定义在 Parent.prototype 上的共享方法(如 Parent.prototype.sayHi = function() {}),子类实例根本无法访问。尝试调用时会报错 Uncaught TypeError: child.sayHi is not a function。
  • 构造函数内的方法无法复用,造成内存浪费: 如果为了让子类能调用方法而把函数全部写在父类构造函数内部(即 this.sayHi = function() {}),那么每次子类 new 实例时,都会在内存堆中为该方法重新实例化一个函数对象。1000 个实例就会在内存中产生 1000 份一模一样的方法副本,这违背了面向对象编程中方法共享复用的初衷。
JavaScript中call和apply在继承中的作用是什么
图 4:内存模型切分——call/apply 负责实例属性空间,原型链负责方法共享空间

五、工业级落地:配合原型链实现寄生组合式继承

正是因为 call / apply 只能解决“实例自有属性”的初始化,JavaScript 经典继承方案中必须将它与原型链配合使用。

1. 组合继承的过渡与缺陷

早期的“组合继承”(Combination Inheritance)将两者生硬结合:

function Child(name, age) {
  Parent.call(this, name); // 第一次调用 Parent():为子类实例初始化属性
  this.age = age;
}
Child.prototype = new Parent(); // 第二次调用 Parent():为了连接原型链
Child.prototype.constructor = Child;

这种做法的缺陷在于父类构造函数被调用了两次。在第二步 new Parent() 时,Child.prototype 上会被挂上一组多余的 name 和 colors,虽然它们会被第一步实例自身的同名属性屏蔽,但带来了冗余的内存开销与执行成本。

2. 寄生组合式继承(ES5 的黄金标准)

现代规范中成熟的做法是寄生组合式继承(Parasitic Combination Inheritance)。其核心思路是:用 call 负责属性继承,用 Object.create() 负责原型方法继承,彻底消灭二次调用:

function Parent(name) {
  this.name = name;
  this.colors = ['red', 'blue'];
}
Parent.prototype.sayName = function() {
  console.log(this.name);
};

function Child(name, age) {
  // 1. 借用构造函数:初始化实例自有属性(高效、隔离、可传参)
  Parent.call(this, name);
  this.age = age;
}

// 2. 原型继承:直接以 Parent.prototype 为原型生成对象,不调用 Parent 构造器
Child.prototype = Object.create(Parent.prototype);
// 3. 修复 constructor 指针
Child.prototype.constructor = Child;

Child.prototype.sayAge = function() {
  console.log(this.age);
};

这也是 Babel 将 ES6 class ... extends 编译降级为 ES5 代码时的核心实现方式。在 ES6 中,子类 constructor 内部必须先调用的 super(...args),其底层本质正是语言级对 Parent.call(this, ...args) 的严格封装与规范实现。

JavaScript中call和apply在继承中的作用是什么
图 5:JavaScript 各种继承模式的特征对比与技术选型矩阵

六、常见排查与避坑指南

在实际编写或维护借用构造函数相关代码时,以下几个容易出错的细节需要特别留意:

避坑 1:遗漏上下文导致 this 逃逸或报错

初学者容易笔误将 Parent.call(this, name) 漏写为 Parent(name)。在非严格模式下,这会导致 name 被意外赋值到 window 上,而新实例的 name 为 undefined;在严格模式('use strict')下,则会直接抛出 Cannot set property of undefined 错误。

避坑 2:自有属性定义与 call 的执行顺序颠倒

必须优先执行 Parent.call(this, ...),然后再定义子类的自有属性。如果子类先执行了 this.type = 'custom',随后父类构造函数中若恰好包含 this.type = 'base' 的默认赋值,子类预先设定的属性就会被父类静默覆盖。

避坑 3:勿在父类构造函数中声明通用方法

始终牢记:call 和 apply 的舞台是“属性数据”,而不是“通用方法”。所有需要被子类实例共同使用的逻辑方法,务必挂载到 Parent.prototype 上,配合原型链或 Object.create 传递,以保持轻量且可预测的内存占用。

作者最新文章
相关文章
更多