将函数柯里化的实现与应用

函数柯里化：将多个参数函数变成：每次接收一个参数，并且返回新函数接收余下的参数，最后返回结果的的技术。

原理：就是利用闭包创建一个私有域，使内部变量可以长期保存在内存中，直到内部返回的函数执行完成。（也就是要被柯里化的函数的n个参数都传入完成，一次性完成了计算操作，那么闭包中保存的变量就被释放）

好处：参数复用、延迟执行 bind方法的底层实现，以及有时候后面函数调用的参数只能由前面函数产生而必须函数嵌套时使用。

柯里化实现：

// 函数柯里化
let curry = function (fn) {
    let args = Array.prototype.slice.call(arguments, 1);//取出除了函数外的其它参数保存在args中
    return function () {
        let newArgs = args.concat(Array.from(arguments));//后面每次调用都把参数拼接到args中保存
        if (newArgs.length < fn.length) {//函数参数还没有完全传完
            return curry.call(this, fn, ...newArgs);//重新进行柯里化，实现多次调用
        } else {//如果参数全部传完
            return fn.apply(this, newArgs);//返回全部参数一次性执行函数的结果
        }
    }
}
let sum = function (a, b, c) {
    return a + b + c;
}
let f1 = curry(sum, 1);
console.log(f1(1)(3));  // 5
console.log(f1(2, 3));  // 6

     //    箭头函数写法
     const curry = (fn,arg)=>{
             let length = fn.length
             var arg = arg || []            
             return (...arguments)=>{                
                 newArg = arg.concat(Array.prototype.slice.call(arguments))
                 if (newArg.length<length) return curry.call(this,fn,newArg)
                 else
                    return fn.apply(this,newArg)
             }
            
        }

    //  演示
        const sum=(a,b)=> a+b
        let Sum = curry(sum)
        console.log(Sum(1)(2))  // 3

柯里化应用：

        const summ = (a)=>{
            return (b)=>{
                return a+b
            }
        }
        console.log(summ(2)(3))