JavaScript ES6函数式编程（二）：柯里化、偏应用和组合、管道

上一篇介绍了闭包和高阶函数，这是函数式编程的基础核心。这一篇来看看高阶函数的实战场景。

首先强调两点：

• 注意闭包的生成位置，清楚作用域链，知道闭包生成后缓存了哪些变量
• 高阶函数思想：以变量作用域作为根基，以闭包为工具来实现各种功能

柯里化（curry）

定义：柯里化是把一个多参数函数转换为一个嵌套的一元函数的过程。

先看个简单的例子，这是一个名为 add 的函数：const add = (x, y) => x + y;调用该函数 add(1, 1)、add(1, 2)、add(1, 3)...很普通，缺乏灵活性。

下面是柯里化实现版本：

const addCurried = x => y => x + y;

如果我们用一个单一的参数调用 addCurried，const add1 = addCurried(1)它返回一个函数fn = y => 1 + y，在其中 x 值通过闭包缓存下来。接下来，我们继续传参add1(1); add1(2); add1(3)，有没有感觉比上面的 add 灵活。

上面的实现只是针对接收两个参数相加的柯里化函数，接下来正是开始实现个基础的通用的接收两个参数的柯里化函数：

const curry = (binaryFn) => {
    return function (firstArg) {
        return function (secondArg) {
            return binaryFn (firstArg, secondArg) ;  // 为啥要嵌套那么多呢？基于什么思路呢？思考一下...
        };
    };
};

现在可以用如下方式通过 curry 函数把 add 函数转换成一个柯里化版本：

const autoCurriedAdd = curry(add)
autoCurriedAdd(1)(1)  // 2

这里我们已经体会到柯里化的好处了，那么柯里化是怎样实现的呢？看上面 curry 的实现很容易发现，先传入一个接受二元函数，然后返回一个一元函数，当这个一元函数执行后，再返回一个一元函数，再次执行返回的一元函数时，触发最开始那个二元函数的执行。

这里有一个点很重要——执行时机，接收够两个参数（add 函数接收的参数数量）立即执行，也就是说接收够被柯里化函数的参数数量时触发执行。

好的，我们已经实现了一个基础的柯里化函数。不过，这个 柯里化函数有很大的局限性——只能用于接收两个参数的函数。我们需要的是被柯里化函数的参数可以任意数量，怎么办呢？还好我们已经知道了被柯里化函数的执行时机——接收够被柯里化函数的参数数量时触发执行。下面我们来实现更复杂的柯里化：

// 柯里化函数
const curry = (fn) => {
  if (typeof fn !== 'function') {
    throw Error('No function provided')
  }

  return function curriedFn (...args) {
    if (fn.length > args.length) {  // 未达到触发条件，继续收集参数
      return function () {
        return curriedFn.apply(null, args.concat([].slice.call(arguments)))
      }
    }
    return fn.apply(null, args)
  }
}

这样，我们就能处理多个参数的函数了。比如：

const multiply = (x, y, z) => x*y*z;

const curryMul = curry(multiply);
const result = curryMul(1)(2)(3); // 1*2*3 = 6

偏应用（partial）

偏应用，又称作部分应用，它允许开发者部分地应用函数参数。实际上，偏应用是为一个多元函数预先提供部分参数，从而在调用时可以省略这些参数。

比如我们要在每10ms做一组操作。可以通过 setTimeout 函数以如下方式实现：

setTimeout( () => console.log("Do X task"), 10);
setTimeout( () => console.log("Do Y tash"), 10);

很显然，我们可以用上面的 curry 函数包装成柯里化函数，实现灵活调用：

// 实现一个二元函数，用于柯里化
const setTimeoutWrapper = (time, fn) => {
    setTimeout(fn, time);
}

// 使用 curry 函数封装 setTimeout 来实现一个10ms延迟
const delayTenMs = curry(setTimeoutWrapper)
delayTenMs( () => console.log("Do X task") );
delayTenMs( () => console.log("Do Y task") );

很棒，也能实现灵活调用。但问题是我们不得不创建 setTimeoutWrapper 一样的封装器，这也是一种开销。下面我们看看偏应用的实现：

// 偏应用函数
const partial = (fn, ...partialArgs) => {
  let args = partialArgs
  return (...fullArguments) => {
    let count = 0
    for (let i = 0; i < args.length && count < fullArguments; i++) {
      if (args[i] === undefined) {
        args[i] = fullArguments[count++]
      }
    }
    return fn.apply(null, args)
  }
}

下面用偏应用解决上面的延时10ms问题：

let delayTenMs = partial(setTimeout, undefined, 10);  // 注意此处，让我们少创建了一个 setTimeoutWrapper 封装器
delayTenMs( () => console.log("Do X task") )
delayTenMs( () => console.log("Do Y task") );

现在我们对柯里化有了更清晰的认识。创建偏应用函数时，第一个参数接收一个函数，剩余参数是第一个传入函数所需参数。剩余参数待传入的用undefined占位，执行偏应用函数时填充undefined。

组合（compose）

在了解什么是函数式组合之前，让我们理解组合的概念。

符合“|”被称为管道，它允许我们通过组合一些函数去创建一个能够解决问题的新函数。大致来说，“|”将最左侧的函数输出作为输入发送给最右侧的函数！从技术上讲，该处理过程称为“管道”。

compose 函数：

const compose = (a, b) => (c) => a(b(c))

compose 函数会首先执行 b 函数，并将 b 的返回值作为参数传递给 a。该函数调用的方向是从右至左的（先执行 b，再执行 a）。

可以看到，组合函数 compose 就是传入一些函数。对于传入的函数，我们要求一个函数只做一件事。

下面看下如何应用 compose 函数：

// 通过组合计算字符串单词个数
let splitIntoSpaces = (str) => str.split(" ");   // 分割成数组
let count = (array) => array.length;  // 计算长度

const countWords = compose(count, splitIntoSpaces);

countWord("hello your reading about composition"); // 5

上面的 compose 只能实现两个函数的组合。如何组合更多个函数呢？这就需要借助reduce的威力了：

// 组合多个函数 composeN
const composeN = (...fns) =>
    (value) =>
        fns.reverse().reduce((acc, fn) => fn(acc), value);

管道/序列（pipe）

管道和组合的概念很类似，都是串行处理数据。唯一区别就是执行方向：组合从右向左执行，管道从左向右执行。

// 组合多个函数 pipe
const pipe= (...fns) =>
    (value) =>
        fns.reduce((acc, fn) => fn(acc), value);

下面看下如何应用 pipe 函数：

// 通过管道计算字符串单词个数
let splitIntoSpaces = (str) => str.split(" ");   // 分割成数组
let count = (array) => array.length;  // 计算长度

const countWords = pipe(splitIntoSpaces, count);  // 注意此处的传参顺序

countWord("hello your reading about composition"); // 5

总结

通过这一节的学习，我们知道了高阶函数的一些应用——柯里化、偏应用、组合和管道，每种应用都有特定的应用场景。

其中，柯里化是最常用的一种场景，它的作用是把一个多参数函数转换为一个嵌套的一元函数的过程。随着闭包的产生，我们可以灵活的调用。

组合和管道类似，都是串行处理数据。传入一个初始数据，通过一系列特定顺序的纯函数处理成我们希望得到的数据。

参考链接：

简明 JavaScript 函数式编程——入门篇