JavaScript函数柯里化与组合技术_技术教程

函数柯里化将多参数函数转换为单参数函数序列，如add(1)(2)(3)；组合通过compose或pipe串联函数，实现声明式数据流处理，两者结合提升代码复用性与可读性。

函数柯里化和组合是函数式编程中的两个核心概念，在JavaScript中被广泛使用，尤其在处理高阶函数、构建可复用逻辑和提升代码表达力方面非常有效。它们让开发者能以更声明式的方式组织代码，增强函数的灵活性与可测试性。

什么是函数柯里化

柯里化（Currying）是指将一个接受多个参数的函数转换为一系列只接受单个参数的函数序列。每次调用返回一个新的函数，直到所有参数都被传入并最终执行。

例如，一个原本需要三个参数的函数 f(a, b, c)，经过柯里化后可以写成 f(a)(b)(c)。

示例：实现一个简单的加法柯里化函数

function add(a) {
  return function(b) {
    return function(c) {
      return a + b + c;
    };
  };
}
add(1)(2)(3); // 6

也可以写成更通用的自动柯里化函数：

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    } else {
      return function(...nextArgs) {
        return curried.apply(this, args.concat(nextArgs));
      };
    }
  };
}
// 使用示例
function multiply(a, b, c) {
return a  b  c;
}
const curriedMultiply = curry(multiply);
curriedMultiply(2)(3)(4); // 24
curriedMultiply(2, 3)(4); // 24

柯里化的好处包括：

参数复用：提前固定某些参数，生成更具体的功能函数
延迟计算：不立即执行，等待所有参数到位
提高函数的可组合性

函数组合的基本原理

函数组合（Function Composition）指的是将多个函数连接起来，前一个函数的输出作为下一个函数的输入。数学上表示为：(f ∘ g)(x) = f(g(x))。

在JavaScript中，我们可以实现一个通用的组合函数：

function compose(...functions) {
  return function(value) {
    return functions.reduceRight((acc, fn) => fn(acc), value);
  };
}

示例：字符串处理流程

const toUpperCase = str => str.toUpperCase();
const exclaim = str => str + '!';
const repeat = str => str.repeat(2);
const withExuberance = compose(repeat, exclaim, toUpperCase);
withExuberance('hello'); // "HELLO!HELLO!"

注意：compose 是从右向左执行。如果希望从左到右，可以使用 pipe：

function pipe(...functions) {
  return function(value) {
    return functions.reduce((acc, fn) => fn(acc), value);
  };
}
const withExuberancePipe = pipe(toUpperCase, exclaim, repeat);
withExuberancePipe('hello'); // "HELLO!HELLO!"

柯里化与组合的结合使用

当柯里化与组合结合时，能极大提升代码的抽象能力。柯里化让函数更容易部分应用，而组合则让这些函数能自然串联。

实际场景：数据处理管道

// 柯里化工具函数
const map = fn => arr => arr.map(fn);
const filter = predicate => arr => arr.filter(predicate);
const reduce = (reducer, init) => arr => arr.reduce(reducer, init);
// 数据处理流水线
const processNumbers = pipe(
filter(x => x > 3),
map(x => x * 2),
reduce((acc, x) => acc + x, 0)
);
processNumbers([1, 2, 4, 5, 6]); // (42)+(52)+(6*2) = 8+10+12 = 30

这种风格清晰表达了“先过滤、再映射、最后求和”的意图，每个步骤都是可复用、可测试的独立函数。

优势总结：