JavaScript进阶6之函数式编程与ES6&ESNext规范

柯里化curry

compose是curry的应用
在 lodash/fp
underscore
ramba

curry

function curry(fn){
   
    // 统计传入函数的参数个数
    const len=fn.length
    // 函数命名为的后面重复调用
    return function curried(...args){
   
        // 当传入的参数个数大于等于函数需要的参数个数的时候，则执行函数
        if(args.length>=len){
   
            return fn.apply(this,args)
        }else{
   
            // 否则返回函数并且接收后面传入的参数
            return function(...args2){
   
                // 执行回调curried函数，将参数合并传入下一次回调中
                return curried.apply(this,args.concat(args2))
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

compose

两个函数组合：

function compose(f,g){
   
    return function(x){
   
        return f(g(x))
    }
}
1
2
3
4
5
6
7

不确定个数函数组合：

// 传入多个函数
function compose(...fns){
   
    // 当个数
    if(fns.length===0){
   
        // console.log("-----等于0----");
        // compose不传参数的时候，返回的是一个函数，这个函数传的参数都返回
        return (args)=>args
    }
    if(fns.length===1){
   
        // console.log("----等于1-----");
        // compose传入一个参数的话，就返回这个函数
        return fns[0]
    }
    // compose传入两个及两个以上函数的时候，使用reduce将作为参数的函数从右往左执行
    return fns.reduce((pre,cur)=>(...args)=>pre(cur(...args)))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

示例：

简化版

var compose=(f,g)=>(x)=>f(g(x))
const curry=require('lodash').curry

var toUpperCase=curry(function(str){
   
    return str.toUpperCase()
})

var head=curry(function(x){
   
    return x[0]
})
var initials=function(name){
   
    return name.split(' ').map(compose(toUpperCase,head)).
1
2
3
4
5
6
7
8
9
10
11
12
13
14