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