JavaScript内核与高级编程之：`JavaScript`的柯里化（`Currying`）：其在函数组合中的应用。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

嗨，大家好！今天咱们聊聊柯里化，这名字听着像印度菜，但其实是 JavaScript 里一个相当实用的编程技巧。

咱们今天要聊的，不是咖喱饭，而是柯里化（Currying），以及它在函数组合中的奇妙应用。准备好了吗？那就开始咱们的编程“美食”之旅吧！

什么是柯里化？

想象一下，你是一个厨师，要做一道复杂的菜，比如“麻婆豆腐”。你需要准备各种配料：豆腐、肉末、豆瓣酱、辣椒面等等。

柯里化就像是把这道菜的制作过程分解成几个步骤，每个步骤只需要处理一个或几个配料。比如：

准备豆腐： 先把豆腐切成小块。
准备肉末： 把肉末炒熟。
混合调料： 把豆瓣酱、辣椒面等调料混合在一起。
烹饪： 把豆腐、肉末和调料一起烹饪。

每个步骤都是一个函数，而且每个函数只接受一部分参数。这就是柯里化的核心思想： 把一个接受多个参数的函数，转换成一系列接受单个参数（或部分参数）的函数，最终返回结果。

用 JavaScript 代码来表示，一个简单的加法函数：

function add(x, y) {
  return x + y;
}

console.log(add(2, 3)); // 输出: 5

柯里化之后：

function curriedAdd(x) {
  return function(y) {
    return x + y;
  };
}

const addTwo = curriedAdd(2); // 预先设置 x 的值为 2
console.log(addTwo(3)); // 输出: 5
console.log(curriedAdd(5)(3)); // 输出: 8

可以看到，curriedAdd 函数接受一个参数 x，然后返回一个新的函数，这个新函数接受参数 y，最后返回 x + y 的结果。 curriedAdd(2) 就相当于提前告诉函数，x 的值是 2，并返回一个等待 y 的函数。

总结一下： 柯里化就是把一个多参数函数变成一系列单参数函数的过程。

柯里化的好处

延迟执行/部分应用 (Partial Application): 可以先传入一部分参数，得到一个“半成品”函数，然后在需要的时候再传入剩余的参数来执行。就像上面 curriedAdd(2) 的例子。
提高代码复用性: 通过预先设置一些参数，可以创建出一些特定功能的函数，方便在不同的场景下使用。
函数组合 (Function Composition): 柯里化是函数组合的基础，可以将多个小函数组合成一个更强大的函数。咱们后面会详细讲这个。
代码更清晰易读: 把一个复杂的函数分解成多个小函数，可以使代码更易于理解和维护。

实现柯里化的几种方式

1. 闭包 (Closure) 实现

这是最常见也最容易理解的方式，就像上面的 curriedAdd 例子一样。

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

function multiply(x, y, z) {
  return x * y * z;
}

const curriedMultiply = curry(multiply);

console.log(curriedMultiply(2)(3)(4)); // 输出: 24
console.log(curriedMultiply(2, 3)(4)); // 输出: 24
console.log(curriedMultiply(2)(3, 4)); // 输出: 24
console.log(curriedMultiply(2, 3, 4)); // 输出: 24

这个 curry 函数接受一个函数 fn 作为参数，然后返回一个新的函数 curried。curried 函数会检查传入的参数数量是否达到 fn 所需的参数数量。

如果达到，就直接调用 fn 并返回结果。
如果没有达到，就返回一个新的函数，这个新函数会把之前传入的参数和新的参数合并起来，然后再次调用 curried 函数。

解释一下：

fn.length 获取的是函数 fn 定义时声明的参数个数。
...args 和 ...moreArgs 使用了 ES6 的剩余参数语法，可以将传入的参数收集到一个数组中。
fn(...args) 使用了 ES6 的展开运算符，可以将数组中的元素展开成一个个独立的参数。

2. 使用 `Function.prototype.bind`

bind 方法可以创建一个新的函数，并将 this 的值绑定到指定的对象，同时可以预先设置一些参数。

function greet(greeting, name) {
  return `${greeting}, ${name}!`;
}

const sayHello = greet.bind(null, "Hello"); // 绑定 greeting 为 "Hello"

console.log(sayHello("World")); // 输出: Hello, World!

const sayGoodMorning = greet.bind(null, "Good Morning"); // 绑定 greeting 为 "Good Morning"
console.log(sayGoodMorning("Alice")); // 输出: Good Morning, Alice!

在这个例子中，greet.bind(null, "Hello") 创建了一个新的函数 sayHello，并将 greet 函数的 greeting 参数绑定为 "Hello"。注意 bind 的第一个参数是 this 的指向，这里我们不需要改变 this 的指向，所以传入 null。

3. Lodash 的 `_.curry` 函数

Lodash 是一个流行的 JavaScript 工具库，提供了很多实用的函数，包括 _.curry 函数，可以方便地实现柯里化。

//需要安装 lodash: npm install lodash
const _ = require('lodash');

function divide(x, y) {
  return x / y;
}

const curriedDivide = _.curry(divide);

const divideByTwo = curriedDivide(2); // 预先设置 x 的值为 2
console.log(divideByTwo(4)); // 输出: 0.5

console.log(curriedDivide(10, 5)); // 输出: 2

Lodash 的 _.curry 函数使用起来非常简单，只需要传入需要柯里化的函数即可。

柯里化在函数组合中的应用

函数组合 (Function Composition) 是一种将多个函数组合成一个新函数的技术。就像搭积木一样，把多个小积木搭成一个更大的积木。

函数组合的目的是将多个函数的功能组合在一起，形成一个更强大的功能。

一个简单的例子：

假设我们有两个函数：

double(x): 将数字乘以 2。
square(x): 将数字平方。

我们想创建一个新函数 doubleAndSquare(x)，先将数字乘以 2，然后再平方。

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

function square(x) {
  return x * x;
}

function doubleAndSquare(x) {
  return square(double(x));
}

console.log(doubleAndSquare(5)); // 输出: 100 (先乘以 2 得到 10，再平方得到 100)

这个例子很简单，但是如果我们要组合更多的函数，代码就会变得越来越复杂。

使用函数组合：

我们可以使用一个通用的 compose 函数来实现函数组合。

function compose(...fns) {
  return function(x) {
    return fns.reduceRight((acc, fn) => fn(acc), x);
  };
}

const doubleAndSquareCompose = compose(square, double);

console.log(doubleAndSquareCompose(5)); // 输出: 100

解释一下：

compose(...fns) 接受多个函数作为参数，并返回一个新的函数。
fns.reduceRight((acc, fn) => fn(acc), x) 使用 reduceRight 方法从右向左依次执行函数。
acc 是累加器，保存上一个函数的结果。
fn 是当前要执行的函数。
x 是初始值，也就是传入 doubleAndSquareCompose 的参数。

柯里化和函数组合的关系：

柯里化可以让我们更方便地进行函数组合。因为柯里化可以将一个多参数函数变成一系列单参数函数，这样就可以更容易地将这些函数组合在一起。

一个例子：

假设我们有三个函数：

add(x, y): 将两个数字相加。
multiply(x, y): 将两个数字相乘。
subtract(x, y): 将两个数字相减。

我们想创建一个新函数 addAndMultiplyAndSubtract(x, y, z)，先将 x 和 y 相加，然后将结果乘以 z，最后将结果减去 z。

function add(x, y) {
  return x + y;
}

function multiply(x, y) {
  return x * y;
}

function subtract(x, y) {
  return x - y;
}

function addAndMultiplyAndSubtract(x, y, z) {
  return subtract(multiply(add(x, y), z), z);
}

console.log(addAndMultiplyAndSubtract(1, 2, 3)); // 输出: 6 ((1 + 2) * 3 - 3 = 6)

使用柯里化和函数组合：

const curriedAdd = curry(add);
const curriedMultiply = curry(multiply);
const curriedSubtract = curry(subtract);

const addAndMultiplyAndSubtractCompose = compose(
  curriedSubtract(1), // 先减去 1 (这里假设 z 的值为 1)
  curriedMultiply(3),   // 然后乘以 3 (这里假设 z 的值为 3)
  curriedAdd(1)      // 最后加上 1 (这里假设 x 的值为 1)
);

console.log(addAndMultiplyAndSubtractCompose(2)); // 输出: 6  (compose 函数从右往左执行,所以先执行 add(1,2),然后是 multiply(3,3),然后是 subtract(9,1))

在这个例子中，我们首先使用 curry 函数将 add、multiply 和 subtract 函数柯里化。然后，我们使用 compose 函数将这些柯里化后的函数组合在一起，创建了一个新的函数 addAndMultiplyAndSubtractCompose。

可以看到，使用柯里化和函数组合可以使代码更简洁、更易读，也更容易维护。

实际应用场景

事件处理： 在事件处理中，我们经常需要预先设置一些参数，例如事件类型、事件目标等。可以使用柯里化来实现。
数据验证： 在数据验证中，我们可以将验证规则柯里化，然后将这些规则组合在一起，形成一个完整的验证器。
配置管理： 在配置管理中，我们可以将配置参数柯里化，然后将这些参数传递给不同的函数，实现不同的功能。
React Hooks: 在 React Hooks 中，柯里化可以用于创建自定义 Hooks，方便地复用逻辑。

柯里化的注意事项

参数顺序： 柯里化的参数顺序很重要，需要仔细考虑。
性能： 柯里化会创建多个函数，可能会影响性能。需要根据实际情况进行权衡。
调试： 柯里化后的函数可能会比较难调试，需要使用调试工具来跟踪函数的执行过程。

总结

柯里化是一种强大的编程技巧，可以使代码更简洁、更易读、更容易维护。它在函数组合中发挥着重要的作用，可以帮助我们将多个小函数组合成一个更强大的函数。

希望通过今天的讲解，大家对柯里化有了更深入的了解。在实际开发中，可以根据具体情况灵活运用柯里化，提高代码质量和开发效率。

最后，记住： 柯里化就像烹饪一样，需要耐心和技巧，才能做出美味佳肴！

希望下次有机会再和大家一起交流编程技巧，再见！