深度剖析柯里化，让你的代码更灵活、更优雅！

什么是柯里化？

柯里化（Currying）是一种函数式编程的技术，其主要思想是将一个多参数的函数转换成一系列单参数的函数。这使得我们可以逐步传递参数，每次传递一个参数，返回一个新的函数，直到所有参数都被收集完毕并执行原始函数。这种技术的名字来源于数学家 Haskell Curry。

为什么要使用柯里化？

当使用柯里化时，我们能够获得一些有趣且强大的编程优势。以下是柯里化的一些主要优点，结合实例进行详细说明：

1. 参数复用

柯里化允许我们部分应用函数并在之后的调用中重复使用这部分应用的函数。这对于在不同上下文中多次使用相同的参数集合非常有用。

示例：

// 普通加法函数
function add(a, b, c) {
    return a + b + c;
}

// 使用柯里化创建新的加法函数
const curryAdd = curry(add);

// 部分应用并重复使用
const add2 = curryAdd(2);
console.log(add2(3)(4)); // 输出：9
console.log(add2(1)(5)); // 输出：8

在这个例子中，我们部分应用了加法函数，并创建了一个新的函数add2，它在之后的调用中一直使用参数2。

2. 延迟执行

柯里化使得我们可以逐步传递参数，延迟函数的执行。这对于需要等待所有参数就绪的场景非常有用。

示例：

// 普通乘法函数
function multiply(a, b, c) {
    return a * b * c;
}

// 使用柯里化创建新的乘法函数
const curryMultiply = curry(multiply);

// 逐步传递参数并延迟执行
const multiplyByTwo = curryMultiply(2);
const multiplyByTwoAndThree = multiplyByTwo(3);
console.log(multiplyByTwoAndThree(4)); // 输出：24

在这个例子中，我们逐步传递参数，最终在第三步中执行乘法函数。

3. 函数组合

柯里化方便了函数的组合，可以将多个单参数函数组合成一个函数链。

示例：

// 普通函数
function square(x) {
    return x * x;
}

function double(x) {
    return x * 2;
}

// 使用柯里化创建新的函数链
const currySquare = curry(square);
const curryDouble = curry(double);

// 组合函数链
const squareAndDouble = curryDouble(currySquare(3));

console.log(squareAndDouble()); // 输出：18，先平方后翻倍

在这个例子中，我们使用柯里化创建了两个单参数函数，并将它们组合成了一个函数链。

JavaScript 中的柯里化实现

现在，让我们来看一个简单的 JavaScript 柯里化实现：

function curry(fn) {
    return function judge(...args) {
        if (args.length === fn.length) {
            return fn(...args);
        }
        return function (...argus) {
            return judge(...args, ...argus);
        };
    };
}

这段代码定义了一个curry函数，它接受一个函数fn作为参数，并返回一个新的函数judge。judge函数用于收集参数，如果参数足够执行原始函数，则执行；否则，返回一个新的函数用于继续收集参数。

详细解释

1. curry 函数

function curry(fn) {

这是柯里化函数的定义，它接受一个函数 fn 作为参数。

2. 返回内部函数 judge

    return function judge(...args) {

curry 函数返回了一个新的函数 judge。这个函数用于收集参数，判断是否已经收集足够的参数以执行原始函数 fn。

3. 检查参数是否足够

        if (args.length === fn.length) {
            return fn(...args);
        }

在 judge 函数内部，首先检查当前收集到的参数数量是否等于原始函数 fn 的参数数量。如果相等，说明参数已经足够，直接执行原始函数 fn，并返回结果。

4. 返回新的函数

        return function (...argus) {
            return judge(...args, ...argus);
        };
    };
}

如果参数数量不够，返回一个新的函数。这个新函数使用了剩余参数 ...argus 来收集新传入的参数，并通过递归调用 judge 函数，将已有的参数与新参数合并。这样，通过逐步传递参数，最终在参数数量足够时执行原始函数。

示例：使用柯里化实现加法函数

function add(a, b, c) {
    return a + b + c;
}

const curryAdd = curry(add);

console.log(curryAdd(1)(2)(3)); // 输出：6

在这个示例中，我们使用柯里化将多参数的加法函数转换为可以逐步传递参数的形式。每次传递一个参数，返回一个新的函数，直到所有参数就绪并执行原始的加法函数。