js偏函数与柯里化

偏函数

偏函数，固定函数的某一个或几个参数，返回一个新的函数来接收剩下的变量参数。 举个例子来说明：

    function mul(a, b) {
        return a * b;
    }

我们可以在该函数的基础上使用绑定创建一个double函数：

    let double = mul.bind(null, 2);
    alert( double(3) ); // = mul(2, 3) = 6
    alert( double(4) ); // = mul(2, 4) = 8
    alert( double(5) ); // = mul(2, 5) = 10

调用mul.bind(null, 2)创建新函数double，传递调用mul函数，固定第一个参数上下文为null，第二个参数为2，多个参数传递也是如此。

以上就是偏函数应用，我们创造一个新函数，让现有的一些参数值固定，从而使函数更加灵活。

  function partial(func, ...argsBound) {
    return function(...args) { // (*)
        return func.call(this, ...argsBound, ...args);
        }
    }

    // Usage:
    let user = {
      firstName: "John",
      say(time, phrase) {
        alert(`[${time}]${phrase} : ${this.firstName}!`);
      }
    };

    // add a partial method that says something now by fixing the first argument
    user.sayNow = partial(user.say, new Date().getHours() + ':' + new Date().getMinutes());
    
    user.sayNow("Hello");
    // Something like:
    // [10:00] Hello, John!

柯里化(curring)

柯里化是把一个有n个参数的函数变成n个只有1个参数的函数， 柯里化又称部分求值，字面意思就是不会立刻求值，而是到了需要的时候再去求值。这样就可以大大提升性能。

如下例子

 var overtime = (function() {
  var args = [];

  return function() {
    if(arguments.length === 0) {
      var time = 0;
      for (var i = 0, l = args.length; i < l; i++) {
        time += args[i];
      }
      return time;
    }else {
      [].push.apply(args, arguments);
    }
  }
})();

    overtime(3.5);    // 第一天
    overtime(4.5);    // 第二天
    overtime(2.1);    // 第三天
    //...

    console.log( overtime() );    // 10.1

反柯里化(uncurring)

 Function.prototype.uncurring = function() {
  var self = this;
  return function() {
    var obj = Array.prototype.shift.call(arguments);
    return self.apply(obj, arguments);
  };
 };

我们先来看看上面这段代码有什么作用。

我们要把Array.prototype.push方法转换成一个通用的push函数，只需要这样做：

    var push = Array.prototype.push.uncurring();
    (function() {
      push(arguments, 4);
      console.log(arguments); //[1, 2, 3, 4]
    })(1, 2, 3)

arguments本来是没有push方法的，通常，我们都需要用Array.prototype.push.call来实现push方法，但现在，直接调用push函数，既简洁又意图明了。

不用考虑对象是否拥有这个方法，只要它适用于这个方法，那就可以使用这个方法