js 函数柯里化|极客笔记

js 函数柯里化

函数柯里化（Currying）是一种函数式编程的技朧，它将一个带有多个参数的函数，转换成一系列只接受单一参数的函数。这种转换过程的实质是利用闭包的特性，将多参数函数拆解为单参数函数，并返回一个新的函数。在实际应用中，柯里化可以简化函数的调用方式，增加代码的可读性，方便实现函数的复用。

柯里化的基本原理

柯里化的基本原理是将一个接受多个参数的函数，转化为一系列只接受单个参数的函数。具体转换过程如下：

定义一个原始函数，该函数接受多个参数。
利用闭包的特性，定义一个包裹函数，返回一个新函数。
在新函数中，利用闭包的原理保存外部函数的参数，直至收集到所有参数。
当参数收集完毕后，执行原始函数并返回结果。

示例代码

下面是一个简单的示例代码，演示了如何实现柯里化功能：

// 定义一个原始函数 add，接受两个参数并返回它们的和
function add(x, y) {
    return x + y;
}

// 实现柯里化函数 curry
function curry(fn) {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn(...args);
        } else {
            return function (...rest) {
                return curried(...args, ...rest);
            };
        }
    };
}

// 对原始函数 add 进行柯里化
const curriedAdd = curry(add);

// 调用柯里化函数
console.log(curriedAdd(1)(2)); // 输出 3
console.log(curriedAdd(5)(3)); // 输出 8
console.log(curriedAdd(2, 3)); // 输出 5

在上面的示例中，我们首先定义了一个原始函数 add，用来求两个数的和。然后我们定义了一个 curry 函数，用于实现柯里化功能。在 curry 函数中，我们通过闭包来保存每次传入的参数，直至参数数量足够执行原始函数。

最后，我们对原始函数 add 进行了柯里化处理，得到了 curriedAdd 函数。通过调用 curriedAdd 函数，我们可以按照不同的方式传入参数，从而实现函数的复用和简化调用方式。

柯里化的应用场景

柯里化在实际开发中有许多应用场景，其中最常见的包括参数复用、延迟调用和函数定义的模块化。下面我们将分别介绍这几个应用场景。

参数复用

柯里化可以将一个多参数函数转化为一个接受单个参数的函数序列，通过这种方式实现参数的复用。例如，在一个计算税额的函数中，我们可以将税率参数固定，实现更加灵活的计算方式。

// 定义一个计算税额的原始函数
function calculateTax(price, rate) {
    return price * rate;
}

// 对原始函数进行柯里化
const curriedTax = curry(calculateTax);

// 固定税率为 0.1，再次调用 curriedTax 函数
const calculateWithRate10 = curriedTax(0.1);
console.log(calculateWithRate10(100)); // 输出 10
console.log(calculateWithRate10(200)); // 输出 20

通过柯里化的方式，我们固定了税率为 0.1，之后每次调用 calculateWithRate10 函数时，只需要传入商品价格即可计算税额，省去了每次传入相同参数的麻烦。

延迟调用

柯里化还可以延迟函数的执行，在收集到所有参数后再一次性执行，实现延迟调用的效果。这种方式常用于异步处理或者性能优化。

// 定义一个延迟调用的原始函数
function delayFunction(fn, ...args) {
    return function () {
        return fn(...args);
    };
}

// 对原始函数进行柯里化
const curriedDelay = curry(delayFunction);

// 延迟调用一个简单的函数
const delayedAdd = curriedDelay((x, y) => x + y, 3, 4);
console.log(delayedAdd()); // 输出 7

在上面的示例中，我们定义了一个 delayFunction 函数，用于延迟调用其他函数。通过柯里化的方式，我们可以提前传入参数，并在需要时一次性执行。这种延迟调用的方式能够减少函数的执行次数，提高性能。

函数定义的模块化

柯里化可以将函数定义模块化，将各个功能模块拆分为独立的单一参数函数，便于组合和复用。这种方式适用于需要灵活组合不同功能模块的场景。

// 定义一个模块化的计算函数
function multiply(x, y) {
    return x * y;
}

function addOne(x) {
    return x + 1;
}

// 对函数进行柯里化
const curriedMultiply = curry(multiply);
const curriedAddOne = curry(addOne);

// 组合不同功能模块
const composedFunction = curriedAddOne(2)(curriedMultiply(3)(4));
console.log(composedFunction); // 输出 13

在以上示例中，我们将两个独立的功能模块 multiply 和 addOne，通过柯里化的方式拆分为单一参数函数。然后，我们可以按照不同的方式组合这些功能模块，得到新的函数。这种模块化的方式简化了函数的定义和调用，增强了代码的可维护性。