JavaScript 函数式编程中 compose 实现

上一篇文章介绍了javascript函数式编程中curry(柯里化)的实现,当然那个柯里化是有限参数的柯里化,等有机会在补上无限参数的那一种柯里化,这次主要说的是javascript函数式编程中另外一个很重要的函数composecompose函数的作用就是组合函数的,将函数串联起来执行,将多个函数组合起来,一个函数的输出结果是另一个函数的输入参数,一旦第一个函数开始执行,就会像多米诺骨牌一样推导执行了。

最近在学习函数式编程,记录了一些笔记,也总结了一些自己的理解。我准备整理一下陆陆续续发出来,本文不算是一篇文章吧,算是自己在学习函数式编程中的一些总结,也算一个引子。

简介

比如有这样的需求,要输入一个名字,这个名字有由firstName,lastName组合而成,然后把这个名字全部变成大写输出来,比如输入jacksmith我们就要打印出来,‘HELLO,JACK SMITH’

我们考虑用函数组合的方法来解决这个问题,需要两个函数greeting,
toUpper

var greeting = (firstName, lastName) => 'hello, ' + firstName + ' ' + lastName
var toUpper = str => str.toUpperCase()
var fn = compose(toUpper, greeting)
console.log(fn('jack', 'smith'))
// ‘HELLO,JACK SMITH’

这就是compose大致的使用,总结下来要注意的有以下几点

  • compose的参数是函数,返回的也是一个函数
  • 因为除了第一个函数的接受参数,其他函数的接受参数都是上一个函数的返回值,所以初始函数的参数是多元的,而其他函数的接受值是一元
  • compsoe函数可以接受任意的参数,所有的参数都是函数,且执行方向是自右向左的,初始函数一定放到参数的最右面

知道这三点后,就很容易的分析出上个例子的执行过程了,执行fn('jack', 'smith')的时候,初始函数为greeting,执行结果作为参数传递给toUpper,再执行toUpper,得出最后的结果,compose的好处我简单提一下,如果还想再加一个处理函数,不需要修改fn,只需要在执行一个compose,比如我们再想加一个trim,只需要这样做

var trim = str => str.trim()
var newFn = compose(trim, fn)
console.log(newFn('jack', 'smith'))

就可以了,可以看出不论维护和扩展都十分的方便。

一些约束

  • 不要为了延迟执行,而简单地用一个函数把另一个函数包起来。
  • 参数命名的时候,不要把参数名限制在特定的数据上,容易造成重复造轮子。
  • 函数不依赖外部值

实现

例子分析完了,本着究其根本的原则,还是要探究与一下compose到底是如何实现的,首先解释介绍一下我是如何实现的,然后再探求一下,javascript函数式编程的两大类库,lodash.jsramda.js是如何实现的,其中ramda.js实现的过程非常函数式。

纯函数

我的实现

我的思路是,既然函数像多米诺骨牌式的执行,我首先就想到了递归,下面就一步一步的实现这个compose,首先,compose返回一个函数,为了记录递归的执行情况,还要记录参数的长度len,还要给返回的函数添加一个名字f1

var compose = function(...args) {
    var len = args.length
    return function f1() {

    }
}

函数体里面要做的事情就是不断的执行args中的函数,将上一个函数的执行结果作为下一个执行函数的输入参数,需要一个游标count来记录args函数列表的执行情况。

var compose = function(...args) {
    var len = args.length
    var count = len - 1
    var result
    return function f1(...args1) {
        result = args[count].apply(this, args1)
        count--
        return f1.call(null, result)
    }
}

这个就是思路,当然这样是不行的,没有退出条件,递归的退出条件就是最后一个函数执行完的时候,也就是count0的时候,这时候,有一点要注意,递归退出的时候,count游标一定要回归初始状态,最后补充一下代码

var compose = function(...args) {
        var len = args.length
        var count = len - 1
        var result
        return function f1(...args1) {
            result = args[count].apply(this, args1)
            if (count <= 0) {
                count = len - 1
                return result
            } else {
                count--
                return f1.call(null, result)
            }
        }
    }

这样就实现了这个compose函数。后来我发现递归这个完全可以使用迭代来实现,使用while函数看起来更容易明白,其实lodash.js就是这么实现的。

1.概念

函数式编程中函数是一等公民,即普通人。对于函数,强调纯函数的概念。什么是纯函数呢?

纯函数是这样一种函数,相同的输入,永远会得到相同的输出,而且没有任何可观察的副作用。

比较明显的一个例子就是slice和splice。前者纯而后者不纯,想想为什么~

这里说的没有副作用具体是什么呢?像上面我提到的splice,它的副作用就是修改了本来的数据,还有一些容易想到的情况,如向数据库插入了数据,打印了数据,获取了用户输入等。
总之,就是一切跟函数外部环境反生交互的行为。

归根结底,这些行为很容易导致“相同的输入返回相同的结果”这一概念的失效。这也是我们尽量避开它们的原因。

lodash实现

lodash的思路同上,不过是用迭代实现的,我就把它的源代码贴过来看一下

var flow = function(funcs) {
    var length = funcs.length
    var index = length
    while (index--) {
        if (typeof funcs[index] !== 'function') {
            throw new TypeError('Expected a function');
        }
    }
    return function(...args) {
        var index = 0
        var result = length ? funcs[index].apply(this, args) : args[0]
        while (++index < length) {
            result = funcs[index].call(this, result)
        }
        return result
    }
}
var flowRight = function(funcs) {
    return flow(funcs.reverse())
}

可以看出,lodash的本来实现是从左到右的,但也提供了从右到左flowRight,还多了一层函数的校验,而且接收的是数组,不是参数序列,而且从这行var result = length ? funcs[index].apply(this, args) : args[0]可以看出允许数组为空,可以看出还是非常严谨的。我写的就缺少这种严谨的异常处理。

2.为什么追求纯?

为什么要花这么多力气去实现纯函数呢,可见的几点好处如下:

结论

这次主要介绍了函数式编程中的compose函数的原理和实现方法,由于篇幅原因,我把打算分析的ramda.js澳门新葡亰3522平台游戏,源码实现放到下一篇来介绍,可以说ramda.js实现的compose更加函数式,需要单独好好分析。

可缓存性(Cacheable)

重复的计算不需要多次计算,这就是可缓存性。

let addFive = memoize(x=>x+5)

addFive(1); 
addFive(1);
addFive(1); 
//真正的计算只会发生一次。

memoize的实现很简单,使用一个对象来存储计算过的值即可。下面是一个简单的实现

const momize=(func)=>{
    //cache对象用于存储计算过的值
    let cache={}

    return ()=>{
        let key = JSON.stringify(arguments)
        if(!cache[key]){
            cache[key] = func.apply(this,arguments)
        }

        return cache[key]
    }
}

可移植性(Portable)

纯函数的依赖很明确,需要的数据都在参数中体现了。这样做,使应用更加灵活。因为一切的依赖都参数化了,当依赖变化时,直接把新的依赖传递进去就好了。