Vue.js

Appearance

On this page

5. 柯里化：Ramda 的“魔法”核心 ​

欢迎来到本书的第二部分。在这里，我们将深入探索驱动 Ramda 强大组合能力的两个核心机制：柯里化（Currying） 和 函数组合（Function Composition）。

在上一章我们已经初步见识了 Ramda 自动柯里化的威力。现在，是时候揭开它神秘的面纱了。柯里化听起来可能有点学术化，但它的核心思想非常直观，而且极其强大。它正是 Ramda “魔法”的核心所在。

什么是柯里化？ ​

想象一个函数，它需要三个参数来完成工作，比如 add(a, b, c)，它会返回 a + b + c 的结果。

通常，我们这样调用它：

javascript
const add = (a, b, c) => a + b + c;
add(1, 2, 3); // 6

我们一次性把所有“原料”（参数）都给了它。

柯里化（Currying），则是一种将这个接收多个参数的函数，转换成一系列只接收单个参数的函数的技术。

经过柯里化之后，add 函数会变成这样：

javascript
// 这是一个柯里化版本的 add 函数
const curriedAdd = a => b => c => a + b + c;

// 你可以像这样“分步”调用它
const add1 = curriedAdd(1);     // add1 是一个新函数：b => c => 1 + b + c
const add1and2 = add1(2);       // add1and2 是一个新函数：c => 1 + 2 + c
const result = add1and2(3);     // result 是 6

// 当然，你也可以一次性调用
curriedAdd(1)(2)(3); // 6

简单来说，柯里化就是：你给函数一个参数，它会“吃掉”这个参数，然后返回一个等待下一个参数的新函数。 这个过程会一直持续，直到所有参数都被“喂饱”，最后它才会返回最终的计算结果。

Ramda 的自动柯里化 ​

手动实现柯里化会有些繁琐。而 Ramda 的美妙之处在于，它所有的函数都是自动柯里化的。

这意味着你不需要自己去做转换。你既可以像普通函数一样，一次性提供所有参数；也可以只提供部分参数，从而得到一个“部分应用”的新函数。

让我们以 Ramda 的 R.add 和 R.replace 为例：

R.add

javascript
import { add } from 'ramda';

add(3, 4); // 7，一次性提供所有参数

const add5 = add(5); // 只提供一个参数，返回一个新函数
add5(10); // 15

add5 成了一个高度特化、可复用的函数。你可以把它用在任何需要“加 5”的场景，比如在一个 map 操作中：

javascript
import { add, map } from 'ramda';

const add5 = add(5);
map(add5, [1, 2, 3]); // [6, 7, 8]

R.replace

R.replace 函数接收三个参数：replace(pattern, replacement, str)。

javascript
import { replace } from 'ramda';

// 完整的调用
replace('foo', 'bar', 'foo foo foo'); // 'bar foo foo'

// 部分应用：创建一个专门用于将 “foo” 替换成 “bar” 的函数
const replaceFooWithBar = replace('foo', 'bar');
replaceFooWithBar('this is a foo sentence'); // 'this is a bar sentence'

// 再进一步：创建一个专门用于将任何字符串中的 “-“ 替换成 “_” 的函数
const snakeCase = replace(/-/g, '_');
snakeCase('hello-world-from-ramda'); // 'hello_world_from_ramda'

柯里化为何如此重要？ ​

柯里化是函数式编程的“粘合剂”。它让我们可以轻松地实现：

  1. 参数复用与函数特化：就像上面的 add5 和 snakeCase 的例子，我们可以通过提供部分参数，快速创建出更具体、更专用的函数。这极大地提高了代码的复用性。

  2. 优雅的函数组合：柯里化是实现 pipe 和 compose 的关键。回顾一下上一章的例子：

    javascript
    const getActiveEmails = pipe(
  filter(prop('active')),
  map(prop('email')),
  map(toUpper)
);

    这里的 filter(prop('active')) 和 map(prop('email')) 能够无缝地接入 pipe 流水线，正是因为柯里化在起作用。

    • prop('active') 返回一个函数，它等待一个对象，然后返回该对象的 active 属性。
    • filter(...) 接收了这个函数作为它的第一个参数，但它还需要数据（一个数组）。由于柯里化，filter(prop('active')) 返回了一个新函数，这个新函数完整地封装了“筛选出 active 属性为 true 的所有元素”这个逻辑，并且正在等待一个数组的到来。

    pipe 中的每一个环节，都是一个等待接收上一步输出结果的函数。柯里化与“数据置后”原则的结合，使得创建这些“等待数据”的函数变得极其自然和简单。

柯里化就像一个函数工厂，它让我们可以基于通用的函数，源源不断地生产出符合我们特定需求的、高度定制化的新函数。正是这种能力，赋予了 Ramda 强大的表现力和灵活性，也让我们能够用一种声明式的方式，将简单的函数“积木”搭建成复杂的业务逻辑“城堡”。

在下一章，我们将深入 Ramda 的源码，亲眼看看这个神奇的 curry 函数是如何实现的。

在 GitHub 上编辑此页