待研究： 柯里化的使用场景

函数柯里化

• 柯里化目的：将一个n元函数转成n个1元函数
• 内部干了一件什么事？
  • 收集参数，如果参数的个数符合要求，则执行函数。
  • 如果参数个数不够，则返回函数继续收集。

      function curry (fn) {
        var _slice = Array.prototype.slice,
            args = _slice.call(arguments, 1),
            len = fn.length;

        if(args.length >= len){
          return fn(...args);
        }else{
          return function _recursion () {
            var newArgs = args.concat(_slice.call(arguments));
            if(newArgs.length >= len){
              return fn(...newArgs);
            }else{
              // 闭包 将外部环境的args改为最新的参数集合
              // 递归 如果参数不够指定长度，返回function
              args = newArgs;
              return _recursion;
            }
          }
        }
      }

      function sum (x, y, z) {
        return x + y + z;
      }
      var newSum = curry(sum); 
      newSum(1)(2)(2);  // 柯里化的目的
      res = curry(sum, 1)(2, 2); // 同样可以运行
      console.log(res);

偏函数

• 使用场景：某些参数是固定的，某些参数是动态的
• 定义： 将一个n元函数转成n-x元的函数
• 如：res = sum.partial(1)(2, 2);

    Function.prototype.partial = function () {
      var args = [].slice.call(arguments),
          _oThis = this;

      return function () {
        var newArgs = args.concat([].slice.call(arguments));
        return _oThis(...newArgs);
      }
    }

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

    var t1 = test.partial(1, 2);
    var res = t1(3);

    console.log(res)

惰性函数

• 本质利用闭包实现直接拿外部环境变量的目的，不需要重复计算
• 且外部环境的变量只需要计算一次。
• 核心： 闭包+重写

  function test(){
    var a= new Date();
    test = function () {
      return a;
    }
    return a;
  }