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 函数式编程——入门篇