Node.js如何实现支持无限链式调用的函数或类？

嘿，这个问题问得太实用了！链式调用不管是在框架（比如Express的路由、Koa的中间件链）还是ORM（像你提到的Eloquent）里都随处可见，核心逻辑其实一点都不复杂——让每个可链式调用的方法执行完后，返回当前对象（或者新的实例，看你的需求）。下面我分两种最常见的场景给你拆解实现方式：

一、类式实现（对应Eloquent模型的调用方式） #

如果你需要像model.where().where().count()这种面向对象的链式调用，用类来实现最直观。每个链式方法都会把状态存在实例属性里，然后返回this（当前实例），这样就能一直往下调用。

举个完整的例子：

class Model {
  constructor() {
    // 用实例属性存查询条件，相当于ORM里的查询构建器状态
    this.queryConditions = [];
  }

  // 链式方法：添加where条件后返回当前实例
  where(field, value) {
    this.queryConditions.push({ field, value });
    return this; // 关键！返回this才能继续链式调用
  }

  // 可选：再加一个链式方法，比如orderBy
  orderBy(field, direction = 'ASC') {
    this.queryConditions.push({ type: 'orderBy', field, direction });
    return this;
  }

  // 终止方法：执行最终逻辑，不需要返回实例
  count() {
    console.log('准备统计符合以下条件的记录：', this.queryConditions);
    // 这里可以替换成实际的数据库查询逻辑，比如用MySQL/PostgreSQL驱动执行count
    return this.queryConditions.filter(item => item.type !== 'orderBy').length;
  }
}

// 使用示例
const userModel = new Model();
userModel
  .where('name', 'Alice')
  .where('age', '>', 18)
  .orderBy('create_time', 'DESC')
  .count(); // 输出统计逻辑，返回条件数量

二、函数式实现（对应app.url().port().listen的方式） #

如果不想用类，用纯函数+闭包也能实现链式调用。闭包可以帮我们隐藏内部状态，对外只暴露可调用的方法，每个方法执行完后返回包含所有方法的对象。

比如模拟一个简单的服务器配置工具：

function createApp() {
  // 闭包保存内部状态，外部无法直接修改
  const appConfig = {
    baseUrl: '',
    port: 3000,
    middleware: []
  };

  // 定义所有可调用的方法，每个方法修改状态后返回app对象
  const app = {
    url(newUrl) {
      appConfig.baseUrl = newUrl;
      return app; // 返回自身，继续链式调用
    },
    port(newPort) {
      appConfig.port = newPort;
      return app;
    },
    use(middlewareFn) {
      appConfig.middleware.push(middlewareFn);
      return app;
    },
    // 终止方法：启动服务器
    listen() {
      console.log(`服务器已启动，地址：${appConfig.baseUrl}:${appConfig.port}`);
      console.log(`已加载${appConfig.middleware.length}个中间件`);
      // 这里可以写实际的http.createServer逻辑
    }
  };

  return app;
}

// 使用示例
const myApp = createApp();
myApp
  .url('http://localhost')
  .port(8080)
  .use((req, res, next) => { console.log('日志中间件'); next(); })
  .listen();

三、进阶：不可变的链式调用 #

有时候你可能希望链式调用不修改原对象（比如在状态管理、纯函数场景），这时候可以让每个链式方法返回新的实例，而不是修改当前实例：

class ImmutableQueryBuilder {
  constructor(conditions = []) {
    // 构造函数接收初始条件，不修改外部数据
    this.conditions = [...conditions];
  }

  where(field, value) {
    // 返回新的实例，原实例保持不变
    return new ImmutableQueryBuilder([...this.conditions, { field, value }]);
  }

  get() {
    console.log('执行查询，条件：', this.conditions);
    // 这里返回查询结果
    return this.conditions;
  }
}

// 使用示例
const query1 = new ImmutableQueryBuilder();
const query2 = query1.where('status', 'active');
console.log(query1 === query2); // false，原实例未被修改
query2.where('role', 'admin').get();

核心总结 #

不管是类还是函数式实现，链式调用的关键只有一个：

• 所有需要链式调用的方法，必须返回一个包含后续可调用方法的对象（当前实例、新实例或者函数式的app对象）
• 终止方法（比如count()、listen()）不需要返回这个对象，因为它们是执行最终逻辑的步骤

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