函数柯里化

函数柯里化(function currying)：是把接收多个参数的函数变换成接收一个单一参数（最初函数的第一个参数）的函数，并且返回接收余下的参数而且返回结果的新函数的技术。

解释有些抽象，先来看下面的例子：

//普通函数
function add(num1, num2) {
    return num1 + num2;
}

//柯里化后
function curriedAdd(num1) {
    return function(num2) {
        return num1 + num2;
    }
}

alert(add(2, 3);  //5
alert(curriedAdd(3)(5)); //8

实际上，就是把add函数的num1，num2两个参数变成了先用一个函数接收num1参数然后返回一个函数去处理num2参数。

函数柯里化的用处：

1.参数复用

function check(reg, str) {
    return reg.test(str);
}

check(/d+/g, 'test');   //false
check(/[a-z]+/g, 'test'); //true

function curryingCheck(reg) {
    return function(str) {
        return reg.test(str);
    }
}

var hasNumber = curryingCheck(/d+/g);

hasNumber('test1');   //true
hasNumber('testtest');  // false
hasNumber('abc');  //false

 上面的示例，就是对check()函数第一个参数reg进行了复用。

2.提前确认

var addEvent = function(element, event, handler) {
    if(document.addEventListener) {
        if(element && event && handler) {
            element.addEventListener(event, handler, false);
        }
    } else {
        if(element && event && handler) {
            element.attachEvent('on' + event, handler);
        }
    }
}


var addEvent = (function() {
    if(document.addEventListener) {
        return function(element, event, handler) {
            if(element && event && handler) {
                element.addEventListener(event, handler, false);
            }
        };
    } else {
        return function(element, event, handler) {
            if(element && event && handler) {
                element.attachEvent('on' + event, handler);
            }
        };
    }
})();

调用函数执行一次判断后返回一个函数，之后同一个用户就不用再进行判断了。

3.延迟运行

Function.prototype.bind = function(context) {
    var _this = this;   
    var args = Array.prototype.slice.call(arguments, 1);

    return function() {
        return _this.apply(context, args);
    }
}

我们在JavaScript中经常使用的bind()方法，实现的机制就是currying。

柯里化函数通常由以下步骤动态创建：调用另一个函数并为它传入要柯里化的函数和必要参数。下面是创建柯里化函数的通用方式：

function curry(fn) {
    var args = Array.prototype.slice.call(arguments, 1);
    
    return function() {
        var innerArgs = Array.prototype.slice.call(arguments);
        var finalArgs = args.concat(innerArgs);
        return fn.apply(null, finalArgs);
    }
}

 实现一个curry()函数， 将普通函数柯里化

function curry(fn, args=[]) {
    return function() {
        let rest = [...args, ...arguments];
        if(rest.length < fn.length) {
            return curry.call(this, fn, rest);
        } else {
            return fn.apply(this, rest);
        }
    }
}

function add(x, y, z) {
    return a + b + c;
}

let sum = curry(add);
console.log(sum(1)(2)(3));   //6
console.log(sum(1)(2, 3));   //6

函数柯里化的性能问题：

1. 存取arguments对象通常要比存取命名参数要慢一点
2. 一些老版本的浏览器在arguments.length的实现上是相当慢的
3. 使用fn.apply()和fn.call()通常比直接调用fn()稍微慢点
4. 创建大量嵌套作用域和闭包函数会带来开销，无论是在内存上还是速度上。

一道经典面试题

//实现一个add方法，使计算结果能够满足如下预期：

add(1)(2)(3) = 6;
add(1, 2, 3)(4) = 10;
add(1)(2)(3)(4)(5) = 15;

function add() {
    var _args = Array.prototype.slice.call(arguments);

    var _adder = function() {
        _args.push(...arguments);
        return  _adder;
    };
    
    _adder.toString = function() {
        return _args.reduce(function(a, b) {
            return a + b;
        });
    }
    return _adder;
}

add(1)(2)(3)    //6
add(1, 2, 3)(4)  //10
add(1)(2)(3)(4)(5)   //15
add(2, 6)(1)  //9

参考链接：详解JS函数柯里化