函数柯里化

柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。
简单求和函数示例：

let sum = function(x,y){
  return x + y
}
sum(3,4) //  7

let curry = function(x){
  return function(y){
    return x + y
  }
}
curry(3)(4) //   7

sum函数实现console.log(sum(1)(2)(3)) 为6

let sum = function(a){
  return function(b){
    return function(c){
      return a+b+c
    }
  }
}

函数柯里化的通用实现--以sum方法为例

function curry(fn){
    // 参数1是传递给slice函数的，即下标1到最后的所有参数
    //call()的第一个参数是绑定的调用者，后边的参数是要绑定调用者的函数所需的参数
    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)
    }
}
function sum(num1,num2){
    return num1 + num2
}
// curriedSum=function(){}  args = 5 ,
var curriedSum = curry(add,5)
//curriedSum(3):finalArgs=[5,3] return sum.apply(null,[5,3])
console.log(curriedSum(3)) // 8

函数的入参总个数可以用length来获取

function s(a,b,c){
  ...
}
s.length  //3

所以可以通过入参个数来实现任意数量参数的函数柯里化

// 支持多参数传递
function progressCurrying(fn, args) {

    var _this = this
    var len = fn.length;
    var _args = args || [];//第一次传入的参数

    return function() {
        var args = Array.prototype.slice.apply(arguments);
        // 将所有参数加入args
        args = Array.prototype.concat.call(_args, args);

        // 如果参数个数小于最初的fn.length，则递归调用，继续收集参数
        if (args.length < len) {
            return progressCurrying.call(_this, fn, args);
        }

        // 参数收集完毕，则执行fn
        return fn.apply(this, args);
    }
}
function sum(num1,num2,num3,num4,num5){
    return num1 + num2 + num3 + num4 + num5
}
var add = progressCurrying(sum)
console.log(add(1)(2)(3)(4)(5))//15

柯里化的应用-参数复用
以下代码来源于https://www.cnblogs.com/hmchen/p/11564394.html

// 正常封装check函数进行字符串正则匹配
function check(reg, txt) {
    return reg.test(txt)
}

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

// 使用柯里化函数进行字符串正则匹配
function curryingCheck(reg) {
    return function(txt) {
        return reg.test(txt)
    }
}

var hasNumber = curryingCheck(/\d+/g)
var hasLetter = curryingCheck(/[a-z]+/g)
 
hasNumber('test1')      // true
hasNumber('testtest')   // false
hasLetter('21212')      // false

函数柯里化-提前确认

var on = (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);
            }
        };
    }
})();

函数柯里化-延迟运行

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

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