柯里化是将多参数函数转换为一系列单参数函数的过程，通过闭包保存已传参数，待参数满足时执行原函数；支持部分调用、占位符及显式触发，提升函数组合与复用能力。

柯里化（Currying）是将一个接收多个参数的函数，转换为一系列只接收一个参数的函数的过程。每次调用返回一个新的函数，直到收集够所有参数后才真正执行原函数。

柯里化的核心思想

把多参数函数“拆开”，每次只传一个参数，利用闭包保存已传入的参数，等参数数量满足时再触发计算。

• 不是简单地分多次调用，而是返回新函数来“记住”已有参数
• 支持部分调用：传一部分参数，得到可继续调用的新函数
• 最终调用时才执行原始逻辑，中间过程不计算

手写一个基础柯里化函数

最常用的方式是根据目标函数的 期望参数个数（length） 来判断是否完成收集：

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    } else {
      return function(...moreArgs) {
        return curried.apply(this, args.concat(moreArgs));
      };
    }
  };
}

使用示例：

function add(a, b, c) {
  return a + b + c;
}
const curriedAdd = curry(add);
console.log(curriedAdd(1)(2)(3)); // 6
console.log(curriedAdd(1, 2)(3)); // 6
console.log(curriedAdd(1)(2, 3)); // 6

更灵活的柯里化（支持占位符和显式结束）

实际中常需要支持占位符（如 _）或手动触发执行（比如传空数组或 null）。可以这样增强：

• 用特殊占位符跳过某个位置，后续补上
• 当传入 null / undefined / [] 时，视为“暂不填，继续等待”
• 提供 resolve() 方法强制执行

简化版带占位符的实现：

function curryWithPlaceholder(fn, placeholder = _) {
  return function curried(...args) {
    const finalArgs = [];
    let idx = 0;
    let argIdx = 0;

    while (finalArgs.length < fn.length && (idx < args.length || finalArgs.length < fn.length)) {
      if (argIdx < args.length && args[argIdx] !== placeholder) {
        finalArgs.push(args[argIdx]);
      } else if (finalArgs.length < fn.length) {
        finalArgs.push(placeholder);
      }
      argIdx++;
      idx++;
    }

    if (finalArgs.every(arg => arg !== placeholder)) {
      return fn.apply(this, finalArgs);
    } else {
      return function(...moreArgs) {
        const merged = finalArgs.map(arg =>
          arg === placeholder && moreArgs.length ? moreArgs.shift() : arg
        );
        return curried.apply(this, merged.concat(moreArgs));
      };
    }
  };
}

现代写法：用箭头函数和 rest/spread 简洁表达

如果明确参数个数，也可以直接写固定版本，更轻量、易读：

const add3 = a => b => c => a + b + c;
console.log(add3(1)(2)(3)); // 6

这种写法适合已知参数结构的场景，但不具备通用性；而通用 curry 函数能适配任意函数。

柯里化不是为了炫技，它让函数组合、配置复用、参数预设变得更自然。用对了，代码会更清晰、更易测试、更容易抽象逻辑。