平时开发不注意，很多面试的时候比较容易问到柯里化，什么是柯里化呢，其实就是一种境界的提高(装个b，莫喷)，其实就是函数进阶的表现，接下来就简单说一下。

一、什么是柯里化？

函数柯里化：是将接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。看到这官方性的解释是不是有点似懂非懂，接下来我们就用使用了n多遍的add举个例子看看：

function add(x,y,z){    //平常方式
     return x+y+z;
}

function addCurry(x){   //柯里化
     return function(y){
          return function(z){
              return x+y+z
          }
     }
}

add(1,2,3);    //6
addCurry(1)(2)(3);    //6

是不是看觉得有点傻啊（我一行代码写完的东西，非给我整个四五行 ，我第一次见它的时候也是这个想法），但是后来才发现它原来真的可能不太一样，我们再扩展一下举个例子看看，不限制调用的次数，也是一道经常见的面试题：

function curAdd1(x){
     var add = function(y){
         x = x+y;
         return add;
     }
     add.toString = function () {
         return x;
     }
     return add;
}
console.log(curAdd1(1)(2)(3));     //6

其中的toString()方法参考：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/toString的一句话 “ 在Function需要转换为字符串时，通常会自动调用函数的 toString 方法。”

还可以再次扩展，不限制调用次数，不限制参数个数：

function curAdd2(){
     // 第一次执行时，定义一个数组存储参数
     var args = Array.prototype.slice.call(arguments);
                
     // 利用闭包特性保存参数
     var add = function() {
         args.push(...arguments);
         return add;
     };

     // 利用上边说的toString的特性做处理
     add.toString = function () {
         return args.reduce(function (a, b) {
             return a + b;
         });
     }
     return add;
}
            
console.log(curAdd2(1,2,3)(4));  //10
console.log(curAdd2(1,2)(3,4)(5));   //15

二、整体封装

//单个参数封装
var currying = function(fn) {
    args = Array.prototype.slice.call(arguments, 1);
    return function() {
        var newArgs = args.concat(Array.prototype.slice.call(arguments));
        return fn.apply(this, newArgs);
    }
}

// 多参数传递
function currying(fn, args) {
    var _this = this;
    var len = fn.length;
    var args = args || [];
 
    return function() {
        var _args = Array.prototype.slice.call(arguments);
        Array.prototype.push.apply(args, _args);
 
        // 如果参数个数小于最初的fn.length，则递归调用，继续收集参数
        if (_args.length < len) {
            return currying.call(_this, fn, _args);
        }
 
        return fn.apply(this, _args);
    }
}

二、使用柯里化的优点

1、参数复用

//平常写法，正则校验
function check(reg, txt) {
    return reg.test(txt);
}
 
check(/\d+/g, '123')       //true+
check(/[a-z]+/g, 'test')    //true

//柯里化后的写法

// curry 后
function curringCheck(reg) {
    return function(txt) {
        return reg.test(txt)
    }
}
 
// 中间函数， 预先设定规则
var hasNumber = curryingCheck(/\d+/g)
var hasLetter = curryingCheck(/[a-z]+/g)

hasNumber('123')      // true
hasLetter('test')      // true

其他的优点之处目前有些没有理解的太清楚，就不在此叙述了。

三、使用柯里化的缺点

        1、因为使用柯里化的时候使用了闭包，最大的缺点最主要的就是闭包所有的缺点，内存得不到释放等

        其实，总的来说，柯里化是js开发过程函数进阶的一个方式，可以减少代码的冗余，增加代码的可读性，使得代码的层次结构更加清楚分明，在逐步的开发中使用，还是有很大的好处。