JavaScript 中怎么用柯里化实现中间件洋葱圈结构-js教程-PHP中文网

洋葱模型的本质是中间件按顺序正向执行请求、反向执行响应的嵌套调用结构，即a→b→c进入、c→b→a返回，依赖函数闭包与next回调时机控制，而非循环遍历。

javascript 中怎么用柯里化实现中间件洋葱圈结构

JavaScript 中用柯里化实现中间件洋葱圈结构，核心是把每个中间件函数设计成接收 next 参数并返回一个处理函数，再通过高阶函数逐层“包裹”执行链，让请求和响应分别正向进入、反向出来。

洋葱模型的本质是什么

洋葱圈结构指中间件按顺序执行：请求时从外到内（A→B→C），响应时从内到外（C→B→A）。它不是靠循环或数组遍历实现，而是靠函数嵌套调用与回调时机控制。

柯里化在这里的作用是：把 (ctx, next) => {...} 这类中间件，转换为可组合的、延迟接收 ctx 的函数形式，从而支持链式“包裹”。

用柯里化构造洋葱链的关键步骤

假设你有一组中间件：

const middlewareA = (ctx, next) => { console.log('→ A'); next(); console.log('← A'); };
const middlewareB = (ctx, next) => { console.log('→ B'); next(); console.log('← B'); };
const middlewareC = (ctx, next) => { console.log('→ C'); next(); console.log('← C'); };

目标是让它们组成 A(B(C(finalHandler))) 的嵌套结构。做法如下：

Alibabacloud Sdk Client Initialization For Java

在 Java 中初始化和管理阿里云 SDK客户端。包括单例模式、线程安全、endpoint 与 region 配置、VPC 终端节点、同步与异步等。

下载

定义一个 compose 函数，接收中间件数组，从右往左柯里化合并
每个中间件被包装成 (ctx) => middleware(ctx, next) 形式，其中 next 是下一个包装后的函数
最内层的 next 是最终的业务处理器（如 async (ctx) => { ctx.body = 'ok'; }）

一个简洁可用的 compose 实现

这是 Koa 风格的柯里化组合器（无依赖、可直接运行）：

function compose(mwList) {
  return function(ctx) {
    function dispatch(i) {
      const fn = mwList[i];
      if (!fn) return Promise.resolve();
      return Promise.resolve(
        fn(ctx, () => dispatch(i + 1))
      );
    }
    return dispatch(0);
  };
}

// 使用示例
const finalHandler = async (ctx) => { ctx.body = 'done'; };
const all = compose([middlewareA, middlewareB, middlewareC]);
await all({ body: null }); // 输出 →A →B →C ←C ←B ←A

注意：这里虽没显式写“柯里化函数”，但 dispatch 闭包捕获了 i 和 mwList，每次调用 fn(ctx, next) 时，next 就是柯里化后的新 dispatch(i+1) —— 这正是柯里化的实际体现：参数分批传入，形成嵌套作用域链。

如果坚持纯柯里化写法（不依赖索引）

也可以手动递归柯里化组合：

const composeCurry = (fns) => {
  if (fns.length === 0) return (ctx) => Promise.resolve();
  if (fns.length === 1) return (ctx) => fns[0](ctx, () => Promise.resolve());
  
  const [first, ...rest] = fns;
  const composedRest = composeCurry(rest);
  
  return (ctx) => first(ctx, () => composedRest(ctx));
};

这种写法更贴近“函数式柯里化”直觉，但实际性能略低、调试稍难，生产环境推荐用带索引的 dispatch 版本。

不复杂但容易忽略：洋葱模型的“反向执行”不是靠栈回溯，而是靠每个中间件在 next() 调用**返回后**继续执行后续逻辑。柯里化确保了 next 始终指向正确的下一层，从而自然撑起整个洋葱结构。