JavaScript 链式调用（Fluent Interface）后隐式执行最终方法实现咨询

针对你需要隐藏applyChanges、链式调用结束后自动执行的需求，有两种落地性极强的实现方案：

方案1：微任务调度（零侵入原有调用写法） #

利用JS事件循环的执行顺序特性：所有同步代码执行完成后才会执行微任务。每次调用链式方法时重置待执行的收尾任务，所有同步链式调用结束后就会自动触发一次applyChanges，完全保留你原有的调用习惯，用户无感知。

实现代码：

class Foobar {
  // 存储待执行的收尾任务标记
  #pendingApplyTask = null

  methodA() {
    // 原有更新状态逻辑
    this.#scheduleApply()
    return this
  }

  methodB() {
    // 原有更新状态逻辑
    this.#scheduleApply()
    return this
  }

  // 私有方法，完全不暴露给使用者
  #applyChanges() {
    // 原有持久化状态逻辑
    console.log('状态已持久化')
  }

  // 调度收尾任务
  #scheduleApply() {
    // 标记上一个待执行的任务失效，避免多次触发
    if (this.#pendingApplyTask) {
      this.#pendingApplyTask.invalid = true
    }

    const currentTask = { invalid: false }
    this.#pendingApplyTask = currentTask

    // 推入微任务队列，同步代码执行完后才会执行
    queueMicrotask(() => {
      if (!currentTask.invalid) {
        this.#applyChanges()
        this.#pendingApplyTask = null
      }
    })
  }

  // 如果需要无方法调用也自动触发，在构造函数调用一次调度即可
  constructor() {
    this.#scheduleApply()
  }
}

调用示例（和原有写法完全一致，用户无需额外操作）：

// 调用1个方法自动触发
new Foobar().methodA()
// 调用多个方法自动触发
new Foobar().methodA().methodB()
// 无调用也自动触发
new Foobar()

注意：如果链式调用中间插入了异步逻辑，该方案会在同步代码执行完后提前触发，这种场景推荐使用方案2。

方案2：Builder回调包装（高可靠性，支持异步场景） #

这是工业界最常用的流式接口隐式收尾方案，把实例构建逻辑收敛到回调函数中，回调执行完成后自动触发收尾方法，完全不存在时序判断问题，兼容性更强。

实现代码：

class Foobar {
  // 构造函数不对外暴露，只能通过静态create方法创建实例
  constructor() {}

  methodA() {
    // 原有更新状态逻辑
    return this
  }

  methodB() {
    // 原有更新状态逻辑
    return this
  }

  // 私有方法，不对外暴露
  #applyChanges() {
    // 原有持久化状态逻辑
  }

  // 对外唯一的实例创建入口
  static create(builderCallback) {
    const instance = new Foobar()
    // 执行用户传入的构建逻辑
    builderCallback(instance)
    // 构建完成自动执行收尾
    instance.#applyChanges()
    // 可按需返回实例给用户使用
    return instance
  }

  // 如果需要支持异步链式调用，改成async版本即可
  static async createAsync(builderCallback) {
    const instance = new Foobar()
    await builderCallback(instance)
    instance.#applyChanges()
    return instance
  }
}

调用示例：

// 同步场景调用
Foobar.create(builder => {
  builder.methodA().methodB()
})

// 异步场景调用
await Foobar.createAsync(async builder => {
  await builder.someAsyncUpdateMethod()
  builder.methodA()
})

内容的提问来源于stack exchange，提问作者phndiaye