函数柯里化

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

其实本质是函数的一种高阶用法：

 

function curringAdd() {
  let args = [].slice.call(arguments, 0);
  
  function add() {
    args = [...args, [].slice.call(arguments, 0)];
    return add
  }
  
  add.toString = function() {
    return args.reduce((t, a) => t + +a, 0);
  }

  return add;
}

console.log(curringAdd(1)(2)(3)) // 6
console.log(curringAdd(1, 2, 3)(4))  // 10
console.log(curringAdd(1)(2)(3)(4)(5)) // 15
console.log(curringAdd(2, 6)(1)) // 9
console.log(curringAdd(1)) // 1

 

function add() { //这段来自简书
    // 第一次执行时，定义一个数组专门用来存储所有的参数
    var _args = Array.prototype.slice.call(arguments);

    // 在内部声明一个函数，利用闭包的特性保存_args并收集所有的参数值
    var _adder = function() {
        _args.push(...arguments);
        return _adder;
    };

    // 利用toString隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
    _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

 method3:

function   addCur(args) {
 args,reduce((pre,cur)=>{
  return pre + cur ;  
}, 0)
}

function myadd(...args1) {
 const sum1 = addCur(args1);
  const fn = (...args2) => {
  const sum2 = addCur(args2);
  return myadd(sum1+sum2)
} 
fn.tostring = () => {
return sum1;
}
return fn       
}
到这里 就可以 实现  myadd(1)(2)(3) == 6 +. true !!! 这种比较！