1、一些术语

1.1 一元函数

只接受一个参数的函数称为一元函数

1
const identity = (x) => x

1.2 二元函数

接受两个参数的函数

1
const add = (x,y) => x + y

1.3 变参函数

接受可变数量参数的函数

1
2
3
4
5
6
7
8
9
10
// es5
 function variadic(a){
     console.log(a)
     console.log(arguments)
 }
 // es6
 const variadic = (a, ...variadic) => {
     console.log(a)
     console.log(variadic)
 }

2、什么是柯里化？

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

呵呵，定义看似简单易懂。但还是让人感觉镜中花，水中月。摸不透柯里化的本质。不要急，看官们。让我们先从简单的二元函数add柯里化开始。

2.1 二元函数柯里化

1
2
3
4
5
6
7
8
9
const addCurried = x => y => x + y
// 其实就是闭包
function addCurried (x){
    return function (y){
        return x + y
    }
}

addCurried(4)(3)  // 7

上面是手动地把接受二元函数add转换为含有嵌套的一元的函数。下面展示如何把该处理过程转换为一个名为curry的方法

1
2
3
4
5
6
7
8
9
10
// es5
const curry = (fn){
    return function (firstParam){
        return function (secondParam){
            return fn(firstParam, secondParam)
        }
    }
}
// es6
let curry = fn => firstParam => secondParam => fn(firstParam, secondParam)

至此，对于函数柯里化，我们应该揭开了TA神秘的面纱。
但是大多数我们写的函数都是变参的。直接看下面变参函数柯里化

2.2 变参函数柯里化

2.2.1 简单变参函数柯里化
1
2
3
4
5
6
7
8
9
let curry = (fn) => {
    if(typeof fn !== 'function'){
        throw Error ('参数必须是函数')
    }
    
    return function curriedFn(...args){
        return fn.apply(null,args)
    }
}

如果我们有个multiply函数

1
2
// es 6
const multiply = (x,y,z)=> x*y*z

我们可以通过以下方式使用2.2中的curry函数

1
curry(multiply)(1,2,3) // 6

下面我们看看，curry是如何运行的。
我们在curry函数里添加了如下代码：

1
2
3
return function curriedFn(...args){
    return fn.apply(null,args)
}

返回函数是一个变参函数，它返回了传入args并通过apply调用函数的结果

1
fn.apply(null, args)

通过curry(multiply)(1,2,3),args将会指向[1,2,3]，由于我们调用了fn的apply，等价于：

1
multiply(1,2,3)

通过2.2 部分我们实现了变参函数的柯里化，接下来我们实现把多参函数转换为一元函数的curry函数,就如函数柯里化的定义一样。

2.2.2 转换为嵌套的一元函数的curry函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
let curry = (fn)=>{
    if(typeof fn !== 'function'){
        throw Error('参数必须是函数')
    }
    
    return function curriedFn(...args){
        if(args.length < fn.length){
            return function(){
                return curriedFn.apply(null,args.concat([].slice.call(arguments)))
            }
        }
        return fn.apply(null args)
    }
}

和之前的curry函数相比我们添加了

1
2
3
4
5
if(args.length < fn.length){
    return function(){
        return curriedFn.apply(null,args.concat([].slice.call(arguments)))
    }
}

让我们逐句理解在这段代码中发生了什么

1
args.length < fn.length

这行代码是检查通过...args传入的参数长度是否小于函数fn参数列表的长度。如果是，就进入if代码块，如果不是，就如之前一样调用整个函数fn。
一旦进入if代码块，就使用apply函数递归地调用curriedFn函数：

1
curriedFn.apply(null,args.concat([].slice.call(arguments)))

此代码片段中：

1
args.concat([].slice.call(arguments))

非常重要，我们使用concat函数连接每次传入的参数，并递归地调用curriedFn。由于我们将所有传入的参数组合并递归调用，终将

1
if(args.length < fn.length)

条件失败，即参数列表长度args和函数参数的长度fn.length相等。程序将调用整个函数fn

1
return fn.apply(null args)

这将产生函数的完整的结果。

好了，函数柯里化就说到这了。