JS函数柯里化

什么是柯里化？

柯里化，即Curring。
是指将一个接收多个参数的函数改造成接收单个参数的函数。这个函数每次返回一个新的函数来处理下个参数，类似fn(param1)(param2)(param3)的形式，直到最后一次执行时输出希望的结果。

举个具体点的例子。两个变量相加改造成柯里化函数，当然这种写法不具有通用性，后面改造。

 	function add(x,y) {
      return x + y;
    }

    function curringAdd(x) {
      return (y)=>{
        return x + y;
      }
    }

    console.log(add(2,3));         // 5
    console.log(curringAdd(2)(3)); // 5

柯里化的优点

可以参数复用或减少判断次数

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

    console.log(check(/(\d)/g, "0123456")); //true
    console.log(check(/([a-z,A-Z])/g, "AaBb")); //true

    function curringCheck(reg) {
      return (target)=>{
        return reg.test(target);
      }
    }

    let hasNum = curringCheck(/(\d)/g);
    let hasLetter = curringCheck(/([a-z,A-Z])/g);

    console.log(hasNum("0123456")); //true
    console.log(hasNum("999")); //true
    console.log(hasLetter("AaBb")); //true
    console.log(hasLetter("cdEF")); //true

延迟执行

来改造下刚看到的add函数，这个函数不会每次收到参数都进行求和，而是在最后一次执行的时候统一进行操作。

    function add() {
      let params = [...arguments];

      let fun = (...val)=>{
        params.push(...val);
        return fun;
      };

      fun.toString = function (){
        return params.reduce(function (a, b) {
          return a + b;
        });
      };

      return fun
    }

    console.log(add(1)(2)(3)) //6

公共方法生成柯里化函数

封装了个方法把普通函数变成柯里化函数

  function createCurringFun(fun, args) {
    let _len = fun.length;
    let _args = args || [];
    return function () {
      _args = Array.prototype.concat(_args,...arguments);
      if(_args.length < _len){
        return createCurringFun(fun, _args)
      }
      return fun(..._args);
    }
  }

  function sum(x,y,z) {
    return x+y+z;
  }

  let test = createCurringFun(sum);
  console.log(test(1)(2)(3)) //6

总结

Curring主要还是为了多参数复用和函数式编程。它对性能有略微影响，但大多数的业务场景下，这细微的影响可以忽略不计。