深度解析：手写JS函数柯里化的实现与应用

一、函数柯里化的基础概念

函数柯里化（Currying）是一种将多参数函数转换为单参数函数序列的技术。其核心思想是通过递归或闭包机制，将一个接收多个参数的函数分解为多个嵌套函数，每个嵌套函数仅接收一个参数并返回下一个函数，直到所有参数被收集完毕后执行原始逻辑。

1.1 柯里化的数学本质

从数学角度看，柯里化将多元函数 ( f(x, y, z) ) 转换为高阶函数 ( f(x)(y)(z) )。例如，加法函数 ( add(a, b, c) = a + b + c ) 柯里化后变为：

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

这种转换使得参数可以分阶段传递，为函数复用提供了基础。

1.2 柯里化与部分应用的区别

需明确区分柯里化（Currying）与部分应用（Partial Application）：

• 柯里化：将多参数函数彻底转换为单参数函数序列，如 f(x)(y)(z)。
• 部分应用：固定部分参数后返回新函数，如 f(x, y) 固定 x 后返回 g(y) = f(x, y)。

二、手写柯里化函数的实现

2.1 基础实现：递归版本

通过递归方式实现柯里化，核心逻辑是每次接收一个参数，当参数数量不足时返回新函数：

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    } else {
      return function(...args2) {
        return curried.apply(this, args.concat(args2));
      };
    }
  };
}
// 示例：柯里化加法函数
const sum = (a, b, c) => a + b + c;
const curriedSum = curry(sum);
console.log(curriedSum(1)(2)(3)); // 6
console.log(curriedSum(1, 2)(3)); // 6

关键点：

• fn.length 获取原始函数的参数数量。
• 通过 args.concat(args2) 累积参数。

2.2 优化版本：支持占位符

为增强灵活性，可实现占位符（如 _）功能，允许跳过特定参数：

function curryWithPlaceholder(fn) {
  return function curried(...args) {
    const argsWithPlaceholder = args.map(arg => 
      arg === '_' ? undefined : arg
    );
    const filledArgs = argsWithPlaceholder.filter(arg => arg !== undefined);
    if (filledArgs.length >= fn.length) {
      // 处理占位符位置
      const finalArgs = [];
      let argIndex = 0;
      for (let i = 0; i < args.length; i++) {
        if (args[i] !== '_') {
          finalArgs[i] = args[i];
        } else {
          finalArgs[i] = argsWithPlaceholder[argIndex++];
        }
      }
      return fn.apply(this, finalArgs);
    } else {
      return function(...args2) {
        // 合并参数时保留占位符位置
        const mergedArgs = args.map((arg, index) => 
          arg === '_' ? args2.shift() || arg : arg
        ).concat(args2);
        return curried.apply(this, mergedArgs);
      };
    }
  };
}
// 示例：使用占位符
const multiply = (a, b, c) => a * b * c;
const curriedMultiply = curryWithPlaceholder(multiply);
console.log(curriedMultiply(1, _, 3)(2)); // 6 (1*2*3)

2.3 ES6简化版本

利用箭头函数和剩余参数简化实现：

const simpleCurry = fn => 
  (...args) => args.length >= fn.length 
    ? fn(...args) 
    : (...args2) => simpleCurry(fn)(...args, ...args2);
// 示例
const join = (a, b, c) => `${a}-${b}-${c}`;
const curriedJoin = simpleCurry(join);
console.log(curriedJoin('a')('b')('c')); // "a-b-c"

三、柯里化的实际应用场景

3.1 参数预处理与配置复用

柯里化可将通用配置封装为函数，后续通过部分应用生成专用函数：

// 通用AJAX请求函数
const ajax = (url, method, data) => {
  return fetch(url, { method, body: JSON.stringify(data) });
};
// 柯里化后
const curriedAjax = curry(ajax);
const postUser = curriedAjax('/api/users', 'POST');
postUser({ name: 'Alice' }).then(/* ... */);

3.2 事件处理与上下文绑定

结合闭包实现事件处理器的上下文隔离：

const handleClick = curry((element, eventType, handler) => {
  element.addEventListener(eventType, handler.bind(element));
});
const button = document.querySelector('button');
const logClick = handleClick(button, 'click', function(e) {
  console.log(`Clicked at ${e.clientX}, ${e.clientY}`);
});

3.3 函数组合与管道构建

柯里化是函数式编程中组合（Compose）的基础：

// 柯里化后的函数组合
const compose = (...fns) => x => 
  fns.reduceRight((v, f) => f(v), x);
const add1 = x => x + 1;
const double = x => x * 2;
const process = compose(double, add1);
console.log(process(3)); // (3+1)*2 = 8

四、性能与边界条件分析

4.1 性能优化策略

• 参数缓存：通过闭包缓存中间结果，避免重复计算。
• 尾调用优化：在支持ES6尾调用的环境中，可改写为尾递归形式。

4.2 边界条件处理

• 参数数量不足：需明确抛出错误或返回部分应用函数。
• 非函数输入：添加类型检查：

  function safeCurry(fn) {
  if (typeof fn !== 'function') {
    throw new TypeError('Expected a function');
  }
  // ...实现逻辑
  }

五、进阶实践：无限柯里化

通过递归和剩余参数实现支持任意数量参数的柯里化：

function infiniteCurry(fn) {
  return function curried(...args) {
    const context = this;
    return function(...args2) {
      const allArgs = [...args, ...args2];
      try {
        return fn.apply(context, allArgs);
      } catch (e) {
        if (e instanceof TypeError && e.message.includes('undefined')) {
          return curried.bind(context, ...allArgs);
        }
        throw e;
      }
    };
  };
}
// 示例：可变参数求和
const infiniteSum = infiniteCurry((...nums) => 
  nums.reduce((a, b) => a + b, 0)
);
console.log(infiniteSum(1)(2)(3)(4)()); // 10 (通过空调用触发执行)

六、总结与最佳实践

1. 适用场景：参数需分阶段传递、函数需高度复用时优先使用。
2. 避免滥用：过度柯里化可能导致代码可读性下降。
3. 工具库集成：Lodash的 _.curry 已提供成熟实现，生产环境可优先使用。

通过手写实现柯里化函数，开发者不仅能深入理解闭包与高阶函数的核心机制，更能在实际项目中灵活应用这一技术优化代码结构。建议从简单场景入手，逐步掌握占位符、无限柯里化等高级特性。