一、什麼是柯里化？

柯里化是一個轉換過程，把一個接受多個引數的函式，轉換成一個接受一個單一引數的函式，並且返回一個函式，返回的函式接受其餘的引數，並返回結果。

舉個例子：

// 無柯里化
var example1 = function (a, b, c) {  
// do something with a, b, and c
};

// 柯里化
var example2 = function(a) {
 return function (b) {
  return function (c) {    
    // do something with a, b, and c
  };
 };
};
 

二、柯里化的實現

1. 首先將引數分割，將除了func之外的引數存進args
2. 返回的函式接受新傳入的引數並與之前的引數合併，從而將所有的引數傳入函式中，並執行真正的函式

var curry = function(func){
    var args = [].slice.call(arguments,1);
    return function(){
        var newArgs = args.concat([].slice.call(arguments));
        return func.apply(this,newArgs);
    }
}

使用如下：

function
 
 add(a, b) {
    return a + b;
}

var addCurry = curry(add,1,2);
addCurry(); //3

//或者
var addCurry = curry(add,1);
addCurry(2); //3

//或者
var addCurry = curry(add);
addCurry(1, 2) // 3

但是此時柯里化的函式只能被呼叫一次，不能實現addCurry(1)(2)的操作

改進版：

比如說add這個函式接受兩個引數，那麼針對柯里化之後的函式，若傳入的引數沒有到達兩個的話，就繼續呼叫curry，繼續接受引數。若引數到達2個了，就直接呼叫add函式。

var curry = function(func,args){
    var length = func.length;
    args = args||[];

    return function(){
        newArgs = args.concat([].slice.call(arguments));
        if(newArgs.length < length){
            return curry.call(this,func,newArgs);
        }else{
            return func.apply(this,newArgs);
        }
    }
}

var addCurry = curry(add);
addCurry(1,2) //3
addCurry(1)(2) //3

進階版：

但這一版柯里化函式仍然不能完全滿足要求，因為它只針對有特定引數個數的函式適用。
在前端面試中有一個關於柯里化的面試題：

實現一個add方法，使計算結果能夠滿足如下預期：
add(1)(2)(3) = 6
add(1, 2, 3)(4) = 10
add(1)(2)(3)(4)(5) = 15

我們之前寫的柯里化是不能滿足這個需求的，因為傳入的引數個數是不固定的。
其實這裡的需求是我們在柯里化的過程中既能返回一個函式繼續接受剩下的引數，又能就此輸出當前的一個結果。

這裡就需要使用函式的toString來完成。
當我們返回函式的時候，會呼叫函式的toString來完成隱式轉換，這樣輸出的就不是函式的字串形式而是我們定義的toString返回的值。這樣就既可以保持返回一個函式，又能夠得到一個特定的值。

function add(){
    var args = [].slice.call(arguments);
    var fn = function(){
        var newArgs = args.concat([].slice.call(arguments));
        return add.apply(null,newArgs);
    } 
    fn.toString = function(){
        return args.reduce(function(a, b) {
            return a + b;
        })
    }
    return fn ;
}

add(1)(2,3) //f 6
add(1)(2,3).toString() //6
add(1)(2)(3)(4)(5).toString() //15

這樣這個函式可以接受任意個數的引數，被呼叫任意次。
呼叫過程：

• add(1)，返回：

function(){
        var newArgs = [1].concat([].slice.call(arguments));
        return add.apply(null,newArgs);
    } 

• add(1)(2,3)，相當於：

(function(){
        var newArgs = args.concat([].slice.call(arguments));
        return add.apply(null,newArgs);
    })(2,3);

此時新引數newArgs為[1,2,3]，同時再次呼叫add，返回函式:

function(){
        var newArgs = [1,2,3].concat([].slice.call(arguments));
        return add.apply(null,newArgs);
    } 

並且此函式的值為toString的結果即6，因此可以輸出6。
其實就是每次都更新當前的引數，重新呼叫一下add函式，並計算當前為止的結果。

其實這個函式沒有什麼通用性，通常用於封裝特定的函式。還是前面兩版柯里化函式比較通用。