call、apply 与 bind

是什么，为什么存在

call()、apply() 和 bind() 都是 Function.prototype 上的方法，用来控制一个可调用值怎样接收 this 和实参。前两个方法立即执行目标函数，最后一个方法返回新函数。这是三者最先要分清的边界。

普通方法调用从点号或方括号左侧取得接收者，例如 account.close() 中的 this 是 account。函数被赋值、解构或作为回调传递后，只剩函数值，原对象不会自动跟随。 显式 this 绑定（explicit this binding） 让调用方在不修改对象的情况下指定接收者。

call() 适合实参数量和位置已经写在调用点的情况。apply() 适合实参已经装在数组或类数组对象中的情况。bind() 适合稍后调用、稳定回调标识，或用 偏应用（partial application） 预先填入前几个实参。

这三个方法不是 this 的全部规则。箭头函数没有自己的 this，类构造函数不能作为普通函数调用，而严格函数与非严格函数对 null、undefined 和原始值接收者的处理也不同。学习这些 API 的重点是识别它们能控制什么，以及目标函数仍保留哪些语义。

这三种操作都要求目标可调用。对数字或普通对象借用 Function.prototype.call 时，接收者规则还没机会生效，运行时就会因目标不可调用而失败。

它们都不会检查接收者是否拥有目标需要的字段。这项契约仍由目标函数负责，因此显式接收者可能在语法上合法，在业务语义上却错误。

工作原理

调用 fn.call(receiver, ...args) 时，call() 先确认 fn 可调用，再以 receiver 作为目标函数的 this，并按原顺序传入其余实参。call() 的返回值和异常都直接来自目标函数。它不会把目标函数永久附加到 receiver 上。

调用 fn.apply(receiver, args) 时，接收者规则与 call() 相同，但第二个参数先被转换为实参列表。这个值可以是数组，也可以是具有 length 和从 0 开始的索引属性的 类数组对象（array-like object） 。传入 null 或 undefined 表示没有实参；其他非对象值会抛出 TypeError。

调用 fn.bind(receiver, ...leadingArgs) 时，目标函数不会执行。运行时创建一个绑定函数，内部保存目标函数、receiver 和前置实参。以后调用绑定函数时，前置实参排在本次实参之前；再次对它调用 call() 或 apply() 不能替换已保存的 this。

每次 bind() 都创建新的函数对象，即使目标、接收者和实参完全相同。这个 回调标识（callback identity） 差异会影响事件移除、订阅取消、缓存键和去重。需要对应的注册与清理操作时，绑定结果本身就是必须保存的资源。

接收者与实参是两个维度

thisArg 不会成为第一个普通形参，普通实参也不会自动成为 this。bind(null, currency) 常用于只预置实参的函数；如果目标函数从不读取 this，null 只是一个明确表示「不使用接收者」的占位值。

严格普通函数会原样收到 call()、apply() 或 bind() 提供的 thisArg。非严格普通函数会把 null 和 undefined 替换为 globalThis，并包装原始值。业务代码不应依赖这种转换，因为模块和类方法使用严格语义。

箭头函数会忽略这些 API 提供的 thisArg，因为它从创建位置读取词法 this。这些方法仍能调用箭头函数并传递实参，bind() 也仍能预置实参。绑定不会把箭头函数变成可构造函数。

apply() 与展开语法

fn.apply(receiver, values) 和 fn.call(receiver, ...values) 在 values 为数组时常得到相同结果，但它们的输入协议不同。apply() 读取 length 与索引属性；展开语法读取 Symbol.iterator。一个值可以只满足其中一种协议。

Reflect.apply(fn, receiver, values) 把目标函数作为显式参数，而不是从 fn.apply 属性取得方法。它适合代理、包装器和通用调用工具，也能避开目标自身名为 apply 的属性。它和 Function.prototype.apply() 一样要求第三个参数是类数组对象，但不能省略该参数。

示例

下面四个示例依次展示立即调用与延迟调用、两种实参协议、稳定回调标识和绑定构造函数。所有输出都由本地 Node 24 运行对应文件得到。

同一个函数的三种调用方式

目标函数同时读取接收者和普通实参。call() 与 apply() 立即返回字符串，bind() 则保存接收者以及前两个实参，等待最后一个实参。

三个调用得到相同业务字符串，但过程不同。前两个表达式已经完成调用；addFee 是可复用的新函数，还需要接收 fee。最后一行证实它和 price 不是同一个函数对象。

bind() 只预置前置实参，不能留下中间空位。若接口需要先固定 amount、以后再提供 currency，应改写形参顺序，使用命名选项对象，或写一个明确的包装函数。

区分类数组对象与可迭代对象

自定义 arrayLike 有索引和 length，但没有迭代器；Set 有迭代器，但没有数组式 length。这两个值把 apply() 与展开语法的协议差异直接暴露出来。

'use strict';

function label(first, second) {
  return `${this.prefix}:${first}|${second}`;
}

const context = { prefix: 'queue' };
const arrayLike = { 0: 'fast', 1: 'bulk', length: 2 };

console.log(label.apply(context, arrayLike));

try {
  console.log(label.call(context, ...arrayLike));
} catch (error) {
  console.log(error.name);
}

const iterable = new Set(['audit', 'mail']);
console.log(label.apply(context, iterable));
console.log(label.call(context, ...iterable));

queue:fast|bulk
TypeError
queue:undefined|undefined
queue:audit|mail

arrayLike 可供 apply() 按索引读取，却不能被展开，因此第二次调用在目标函数执行前抛出 TypeError。Set 的情况正好相反：apply() 看不到 length，于是提供零个实参；展开语法则从迭代器取得两个值。

把 apply() 机械替换为展开语法前，应先确定调用方承诺的是数组、类数组对象还是可迭代对象。若 API 由自己设计，使用真正的数组通常能减少这种协议歧义。

保存一次绑定后的回调

订阅表按函数对象标识添加和移除监听器。Reporter 在构造时绑定一次，因此注册与移除能使用同一个引用；临时再绑定一次则无法匹配已有监听器。

'use strict';

class TopicBus {
  #listeners = new Set();
  on(listener) {
    this.#listeners.add(listener);
  }
  off(listener) {
    this.#listeners.delete(listener);
  }
  emit(value) {
    for (const listener of this.#listeners) listener(value);
  }
  get size() {
    return this.#listeners.size;
  }
}

class Reporter {
  constructor(label) {
    this.label = label;
    this.onValue = this.onValue.bind(this);
  }
  onValue(value) {
    console.log(`${this.label}:${value}`);
  }
}

const bus = new TopicBus();
const reporter = new Reporter('R');

bus.on(reporter.onValue);
bus.emit('open');
bus.off(reporter.onValue);
console.log(bus.size);

bus.on(reporter.onValue);
bus.off(reporter.onValue.bind(reporter));
console.log(bus.size);

R:open
0
1

第一次 off() 删除了准确的引用，所以监听器数量归零。第二次 bind() 产生一个包装在已绑定函数外的新函数，接收者仍然是 reporter，但标识已经不同，因此原监听器留在集合中。

浏览器的 removeEventListener()、Node 的 EventEmitter.off() 以及许多订阅库都有相同要求。还要保存注册选项或取消函数等 API 特有信息；只保留目标方法通常不够。

用绑定函数进行构造

目标函数可构造时，它的绑定函数也可构造。普通调用使用保存的对象，new 调用创建自己的接收者，但两种调用都会收到预置的 'eu' 实参。

'use strict';

function Session(region, id) {
  this.key = `${region}-${id}`;
}

const fallback = { key: 'unset' };
const BoundSession = Session.bind(fallback, 'eu');

BoundSession('ops');
const session = new BoundSession('42');

console.log(fallback.key);
console.log(session.key);
console.log(session instanceof Session);
console.log(session instanceof BoundSession);
console.log(BoundSession.name);
console.log(BoundSession.length);
console.log(Object.hasOwn(BoundSession, 'prototype'));

eu-ops
eu-42
true
true
bound Session
1
false

new BoundSession('42') 忽略 fallback，却保留前置实参。instanceof 会通过绑定目标检查 Session.prototype。绑定函数没有自己的 prototype 属性，所以它能被 new 调用，却不能直接作为 extends 的基类。

这里用普通函数同时演示普通调用和构造调用，不代表一个公开 API 应同时支持两者。生产代码通常应以 class、命名工厂或明确文档固定一种调用形式。

陷阱

用 call() 或 apply() 串联类构造

修复方法： 类继承使用 extends 和 super()。元编程确实需要转发构造时使用 Reflect.construct()，并分别验证原型、返回对象和 new.target。

把 apply() 输入一律当作可展开值

修复方法： 写清输入协议，并在边界转换成真正数组。实参数量可能很大时，不要把整个集合一次展开为函数实参；改用循环、reduce() 或专门接收集合的 API。

在注册与清理位置分别绑定

修复方法： 在所有者初始化时绑定一次，把结果保存到语义明确的字段，并在完整的「注册、触发、清理、再次触发」测试中复用这个引用。

认为再次绑定会替换 this

修复方法： 沿绑定链分别记录目标、首次绑定的接收者、每一批前置实参和调用时实参。需要另一个接收者时，从未绑定的原始函数创建新函数。

依赖非严格模式的全局替换

修复方法： 用严格语义测试，并显式传递业务对象。确实需要全局对象时直接写 globalThis，不要让 call(null) 或 bind(null) 暗中决定它。

把简化实现当作原生替代品

修复方法： 面试练习必须明确列出没有实现的语义，生产代码使用原生方法或 Reflect.apply()。不要修改 Function.prototype 来发布自定义版本，也不要把通过几个样例等同于规范兼容。

延伸阅读

• MDN：Function.prototype.call()
• MDN：Function.prototype.apply()
• MDN：Function.prototype.bind()
• MDN：Reflect.apply()
• ECMAScript 规范：Bound Function Exotic Objects